bslstl_variant_cpp03.h

Go to the documentation of this file.

/// @file bslstl_variant_cpp03.h
///
/// The content of this file has been pre-processed for Doxygen.
///
 
 
// bslstl_variant_cpp03.h                                             -*-C++-*-
 
// Automatically generated file.  **DO NOT EDIT**
 
#ifndef INCLUDED_BSLSTL_VARIANT_CPP03
#define INCLUDED_BSLSTL_VARIANT_CPP03
 
/// @defgroup bslstl_variant_cpp03 bslstl_variant_cpp03
/// @brief  Provide C++03 implementation for bslstl_variant.h
/// @addtogroup bsl
/// @{
/// @addtogroup bslstl
/// @{
/// @addtogroup bslstl_variant_cpp03
/// @{
///
/// <h1> Outline </h1>
/// * <a href="#bslstl_variant_cpp03-purpose"> Purpose</a>
/// * <a href="#bslstl_variant_cpp03-classes"> Classes </a>
/// * <a href="#bslstl_variant_cpp03-description"> Description </a>
///
/// # Purpose {#bslstl_variant_cpp03-purpose}
/// Provide C++03 implementation for bslstl_variant.h
///
/// # Classes {#bslstl_variant_cpp03-classes}
/// See bslstl_variant.h for list of classes
///
/// @see  bslstl_variant
///
/// # Description {#bslstl_variant_cpp03-description}
///  This component is the C++03 translation of a C++11 component,
/// generated by the 'sim_cpp11_features.pl' program.  If the original header
/// contains any specially delimited regions of C++11 code, then this generated
/// file contains the C++03 equivalent, i.e., with variadic templates expanded
/// and rvalue-references replaced by 'bslmf::MovableRef' objects.  The header
/// code in this file is designed to be '#include'd into the original header
/// when compiling with a C++03 compiler.  If there are no specially delimited
/// regions of C++11 code, then this header contains no code and is not
/// '#include'd in the original header.
///
/// Generated on Sun Sep  1 05:39:12 2024
/// Command line: sim_cpp11_features.pl bslstl_variant.h
/// @}
/** @} */
/** @} */
 
/** @addtogroup bsl
 * @{
 */
/** @addtogroup bslstl
 * @{
 */
/** @addtogroup bslstl_variant_cpp03
 * @{
 */
 
#ifdef COMPILING_BSLSTL_VARIANT_H
 
// When generating the expansion of a variadic template, the
// sim_cpp11_features.pl script currently expands the primary template by the
// required number of template arguments.  If there is a partial specialization
// that adds a non variadic template parameter, the generated primary template
// will no longer match the expansion of such specialization.  In the case of
// 'variant' metafunction helpers, such additional template argument is always
// a type parameter.  To work around this issue, a dummy template type
// parameter is added to the primary template and defaulted to
// 'BSLSTL_VARIANT_NOT_A_TYPE'.
typedef void BSLSTL_VARIANT_NOT_A_TYPE;
 
namespace bsl {
 
#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
// {{{ BEGIN GENERATED CODE
// Command line: sim_cpp11_features.pl bslstl_variant.h
#ifndef BSLSTL_VARIANT_VARIADIC_LIMIT
#define BSLSTL_VARIANT_VARIADIC_LIMIT 18
#endif
#ifndef BSLSTL_VARIANT_VARIADIC_LIMIT_A
#define BSLSTL_VARIANT_VARIADIC_LIMIT_A BSLSTL_VARIANT_VARIADIC_LIMIT
#endif
template <class t_HEAD
#if BSLSTL_VARIANT_VARIADIC_LIMIT_A >= 0
        , class t_TAIL_0 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_A >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_A >= 1
        , class t_TAIL_1 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_A >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_A >= 2
        , class t_TAIL_2 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_A >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_A >= 3
        , class t_TAIL_3 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_A >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_A >= 4
        , class t_TAIL_4 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_A >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_A >= 5
        , class t_TAIL_5 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_A >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_A >= 6
        , class t_TAIL_6 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_A >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_A >= 7
        , class t_TAIL_7 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_A >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_A >= 8
        , class t_TAIL_8 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_A >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_A >= 9
        , class t_TAIL_9 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_A >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_A >= 10
        , class t_TAIL_10 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_A >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_A >= 11
        , class t_TAIL_11 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_A >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_A >= 12
        , class t_TAIL_12 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_A >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_A >= 13
        , class t_TAIL_13 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_A >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_A >= 14
        , class t_TAIL_14 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_A >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_A >= 15
        , class t_TAIL_15 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_A >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_A >= 16
        , class t_TAIL_16 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_A >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_A >= 17
        , class t_TAIL_17 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_A >= 17
        , class = BSLS_COMPILERFEATURES_NILT>
class variant;
 
#else
// The generated code below is a workaround for the absence of perfect
// forwarding in some compilers.
template <class t_HEAD, class... t_TAIL>
class variant;
// }}} END GENERATED CODE
#endif
 
// TRAITS
 
                            // ===================
                            // struct variant_size
                            // ===================
 
/// This metafunction calculates the number of alternatives in the (possibly
/// cv-qualified) `bsl::variant` type of (template parameter)
/// `t_BSL_VARIANT`.  The primary template is not defined.
template <class t_BSL_VARIANT>
struct variant_size;
 
template <class t_BSL_VARIANT>
struct variant_size<const t_BSL_VARIANT> : variant_size<t_BSL_VARIANT> {
};
 
template <class t_BSL_VARIANT>
struct variant_size<volatile t_BSL_VARIANT> : variant_size<t_BSL_VARIANT> {
};
 
template <class t_BSL_VARIANT>
struct variant_size<const volatile t_BSL_VARIANT>
: variant_size<t_BSL_VARIANT> {
};
 
#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
// {{{ BEGIN GENERATED CODE
// Command line: sim_cpp11_features.pl bslstl_variant.h
#ifndef BSLSTL_VARIANT_VARIADIC_LIMIT
#define BSLSTL_VARIANT_VARIADIC_LIMIT 18
#endif
#ifndef BSLSTL_VARIANT_VARIADIC_LIMIT_B
#define BSLSTL_VARIANT_VARIADIC_LIMIT_B BSLSTL_VARIANT_VARIADIC_LIMIT
#endif
#if BSLSTL_VARIANT_VARIADIC_LIMIT_B >= 0
template <class t_HEAD>
struct variant_size<variant<t_HEAD> >
: bsl::integral_constant<size_t, 1 +  0u> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_B >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_B >= 1
template <class t_HEAD, class t_TAIL_01>
struct variant_size<variant<t_HEAD, t_TAIL_01> >
: bsl::integral_constant<size_t, 1 +  1u> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_B >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_B >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
struct variant_size<variant<t_HEAD, t_TAIL_01,
                                    t_TAIL_02> >
: bsl::integral_constant<size_t, 1 +  2u> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_B >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_B >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
struct variant_size<variant<t_HEAD, t_TAIL_01,
                                    t_TAIL_02,
                                    t_TAIL_03> >
: bsl::integral_constant<size_t, 1 +  3u> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_B >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_B >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
struct variant_size<variant<t_HEAD, t_TAIL_01,
                                    t_TAIL_02,
                                    t_TAIL_03,
                                    t_TAIL_04> >
: bsl::integral_constant<size_t, 1 +  4u> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_B >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_B >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
struct variant_size<variant<t_HEAD, t_TAIL_01,
                                    t_TAIL_02,
                                    t_TAIL_03,
                                    t_TAIL_04,
                                    t_TAIL_05> >
: bsl::integral_constant<size_t, 1 +  5u> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_B >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_B >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
struct variant_size<variant<t_HEAD, t_TAIL_01,
                                    t_TAIL_02,
                                    t_TAIL_03,
                                    t_TAIL_04,
                                    t_TAIL_05,
                                    t_TAIL_06> >
: bsl::integral_constant<size_t, 1 +  6u> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_B >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_B >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
struct variant_size<variant<t_HEAD, t_TAIL_01,
                                    t_TAIL_02,
                                    t_TAIL_03,
                                    t_TAIL_04,
                                    t_TAIL_05,
                                    t_TAIL_06,
                                    t_TAIL_07> >
: bsl::integral_constant<size_t, 1 +  7u> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_B >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_B >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
struct variant_size<variant<t_HEAD, t_TAIL_01,
                                    t_TAIL_02,
                                    t_TAIL_03,
                                    t_TAIL_04,
                                    t_TAIL_05,
                                    t_TAIL_06,
                                    t_TAIL_07,
                                    t_TAIL_08> >
: bsl::integral_constant<size_t, 1 +  8u> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_B >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_B >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
struct variant_size<variant<t_HEAD, t_TAIL_01,
                                    t_TAIL_02,
                                    t_TAIL_03,
                                    t_TAIL_04,
                                    t_TAIL_05,
                                    t_TAIL_06,
                                    t_TAIL_07,
                                    t_TAIL_08,
                                    t_TAIL_09> >
: bsl::integral_constant<size_t, 1 +  9u> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_B >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_B >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
struct variant_size<variant<t_HEAD, t_TAIL_01,
                                    t_TAIL_02,
                                    t_TAIL_03,
                                    t_TAIL_04,
                                    t_TAIL_05,
                                    t_TAIL_06,
                                    t_TAIL_07,
                                    t_TAIL_08,
                                    t_TAIL_09,
                                    t_TAIL_10> >
: bsl::integral_constant<size_t, 1 + 10u> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_B >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_B >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
struct variant_size<variant<t_HEAD, t_TAIL_01,
                                    t_TAIL_02,
                                    t_TAIL_03,
                                    t_TAIL_04,
                                    t_TAIL_05,
                                    t_TAIL_06,
                                    t_TAIL_07,
                                    t_TAIL_08,
                                    t_TAIL_09,
                                    t_TAIL_10,
                                    t_TAIL_11> >
: bsl::integral_constant<size_t, 1 + 11u> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_B >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_B >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
struct variant_size<variant<t_HEAD, t_TAIL_01,
                                    t_TAIL_02,
                                    t_TAIL_03,
                                    t_TAIL_04,
                                    t_TAIL_05,
                                    t_TAIL_06,
                                    t_TAIL_07,
                                    t_TAIL_08,
                                    t_TAIL_09,
                                    t_TAIL_10,
                                    t_TAIL_11,
                                    t_TAIL_12> >
: bsl::integral_constant<size_t, 1 + 12u> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_B >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_B >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
struct variant_size<variant<t_HEAD, t_TAIL_01,
                                    t_TAIL_02,
                                    t_TAIL_03,
                                    t_TAIL_04,
                                    t_TAIL_05,
                                    t_TAIL_06,
                                    t_TAIL_07,
                                    t_TAIL_08,
                                    t_TAIL_09,
                                    t_TAIL_10,
                                    t_TAIL_11,
                                    t_TAIL_12,
                                    t_TAIL_13> >
: bsl::integral_constant<size_t, 1 + 13u> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_B >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_B >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
struct variant_size<variant<t_HEAD, t_TAIL_01,
                                    t_TAIL_02,
                                    t_TAIL_03,
                                    t_TAIL_04,
                                    t_TAIL_05,
                                    t_TAIL_06,
                                    t_TAIL_07,
                                    t_TAIL_08,
                                    t_TAIL_09,
                                    t_TAIL_10,
                                    t_TAIL_11,
                                    t_TAIL_12,
                                    t_TAIL_13,
                                    t_TAIL_14> >
: bsl::integral_constant<size_t, 1 + 14u> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_B >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_B >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
struct variant_size<variant<t_HEAD, t_TAIL_01,
                                    t_TAIL_02,
                                    t_TAIL_03,
                                    t_TAIL_04,
                                    t_TAIL_05,
                                    t_TAIL_06,
                                    t_TAIL_07,
                                    t_TAIL_08,
                                    t_TAIL_09,
                                    t_TAIL_10,
                                    t_TAIL_11,
                                    t_TAIL_12,
                                    t_TAIL_13,
                                    t_TAIL_14,
                                    t_TAIL_15> >
: bsl::integral_constant<size_t, 1 + 15u> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_B >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_B >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
struct variant_size<variant<t_HEAD, t_TAIL_01,
                                    t_TAIL_02,
                                    t_TAIL_03,
                                    t_TAIL_04,
                                    t_TAIL_05,
                                    t_TAIL_06,
                                    t_TAIL_07,
                                    t_TAIL_08,
                                    t_TAIL_09,
                                    t_TAIL_10,
                                    t_TAIL_11,
                                    t_TAIL_12,
                                    t_TAIL_13,
                                    t_TAIL_14,
                                    t_TAIL_15,
                                    t_TAIL_16> >
: bsl::integral_constant<size_t, 1 + 16u> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_B >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_B >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
struct variant_size<variant<t_HEAD, t_TAIL_01,
                                    t_TAIL_02,
                                    t_TAIL_03,
                                    t_TAIL_04,
                                    t_TAIL_05,
                                    t_TAIL_06,
                                    t_TAIL_07,
                                    t_TAIL_08,
                                    t_TAIL_09,
                                    t_TAIL_10,
                                    t_TAIL_11,
                                    t_TAIL_12,
                                    t_TAIL_13,
                                    t_TAIL_14,
                                    t_TAIL_15,
                                    t_TAIL_16,
                                    t_TAIL_17> >
: bsl::integral_constant<size_t, 1 + 17u> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_B >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_B >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
struct variant_size<variant<t_HEAD, t_TAIL_01,
                                    t_TAIL_02,
                                    t_TAIL_03,
                                    t_TAIL_04,
                                    t_TAIL_05,
                                    t_TAIL_06,
                                    t_TAIL_07,
                                    t_TAIL_08,
                                    t_TAIL_09,
                                    t_TAIL_10,
                                    t_TAIL_11,
                                    t_TAIL_12,
                                    t_TAIL_13,
                                    t_TAIL_14,
                                    t_TAIL_15,
                                    t_TAIL_16,
                                    t_TAIL_17,
                                    t_TAIL_18> >
: bsl::integral_constant<size_t, 1 + 18u> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_B >= 18
 
#else
// The generated code below is a workaround for the absence of perfect
// forwarding in some compilers.
template <class t_HEAD, class... t_TAIL>
struct variant_size<variant<t_HEAD, t_TAIL...> >
: bsl::integral_constant<size_t, 1 + sizeof...(t_TAIL)> {
};
// }}} END GENERATED CODE
#endif
 
#ifdef BSLS_COMPILERFEATURES_SUPPORT_VARIABLE_TEMPLATES
/// This variable template represents the result value of the
/// `bsl::variant_size` metafunction.
template <class t_BSL_VARIANT>
BSLS_KEYWORD_INLINE_VARIABLE constexpr size_t variant_size_v =
    variant_size<t_BSL_VARIANT>::value;
#endif  // BSLS_COMPILERFEATURES_SUPPORT_VARIABLE_TEMPLATES
 
/// This value is returned by `bsl::variant::index()` if
/// `valueless_by_exception()` is `true`.
BSLS_KEYWORD_INLINE_CONSTEXPR size_t variant_npos = -1;
 
                         // ==========================
                         // struct variant_alternative
                         // ==========================
 
/// This metafunction calculates the type of the alternative whose index is
/// (template parameter) `t_INDEX` in the possibly cv-qualified
/// `bsl::variant` type of (template parameter) `t_TYPE`.  If `t_TYPE` is
/// cv-qualified, its cv-qualifiers are applied to the alternative.
template <size_t t_INDEX, class t_TYPE>
struct variant_alternative;
 
template <size_t t_INDEX, class t_TYPE>
struct variant_alternative<t_INDEX, const t_TYPE> {
    typedef typename variant_alternative<t_INDEX, t_TYPE>::type const type;
};
 
template <size_t t_INDEX, class t_TYPE>
struct variant_alternative<t_INDEX, volatile t_TYPE> {
    typedef typename variant_alternative<t_INDEX, t_TYPE>::type volatile type;
};
 
template <size_t t_INDEX, class t_TYPE>
struct variant_alternative<t_INDEX, const volatile t_TYPE> {
    typedef
        typename variant_alternative<t_INDEX, t_TYPE>::type const volatile type;
};
 
#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
// {{{ BEGIN GENERATED CODE
// Command line: sim_cpp11_features.pl bslstl_variant.h
#ifndef BSLSTL_VARIANT_VARIADIC_LIMIT
#define BSLSTL_VARIANT_VARIADIC_LIMIT 18
#endif
#ifndef BSLSTL_VARIANT_VARIADIC_LIMIT_C
#define BSLSTL_VARIANT_VARIADIC_LIMIT_C BSLSTL_VARIANT_VARIADIC_LIMIT
#endif
 
template <size_t t_INDEX,
          class t_HEAD = BSLSTL_VARIANT_NOT_A_TYPE
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 0
        , class t_TAIL_0 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 1
        , class t_TAIL_1 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 2
        , class t_TAIL_2 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 3
        , class t_TAIL_3 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 4
        , class t_TAIL_4 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 5
        , class t_TAIL_5 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 6
        , class t_TAIL_6 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 7
        , class t_TAIL_7 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 8
        , class t_TAIL_8 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 9
        , class t_TAIL_9 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 10
        , class t_TAIL_10 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 11
        , class t_TAIL_11 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 12
        , class t_TAIL_12 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 13
        , class t_TAIL_13 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 14
        , class t_TAIL_14 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 15
        , class t_TAIL_15 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 16
        , class t_TAIL_16 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 17
        , class t_TAIL_17 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 17
        , class = BSLS_COMPILERFEATURES_NILT>
struct Variant_VariantAlternativeImpl;
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 0
template <size_t t_INDEX, class t_HEAD>
struct Variant_VariantAlternativeImpl<t_INDEX, t_HEAD>
: Variant_VariantAlternativeImpl<t_INDEX - 1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 1
template <size_t t_INDEX, class t_HEAD, class t_TAIL_01>
struct Variant_VariantAlternativeImpl<t_INDEX, t_HEAD, t_TAIL_01>
: Variant_VariantAlternativeImpl<t_INDEX - 1, t_TAIL_01> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 2
template <size_t t_INDEX, class t_HEAD, class t_TAIL_01,
                                        class t_TAIL_02>
struct Variant_VariantAlternativeImpl<t_INDEX, t_HEAD, t_TAIL_01,
                                                       t_TAIL_02>
: Variant_VariantAlternativeImpl<t_INDEX - 1, t_TAIL_01,
                                              t_TAIL_02> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 3
template <size_t t_INDEX, class t_HEAD, class t_TAIL_01,
                                        class t_TAIL_02,
                                        class t_TAIL_03>
struct Variant_VariantAlternativeImpl<t_INDEX, t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03>
: Variant_VariantAlternativeImpl<t_INDEX - 1, t_TAIL_01,
                                              t_TAIL_02,
                                              t_TAIL_03> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 4
template <size_t t_INDEX, class t_HEAD, class t_TAIL_01,
                                        class t_TAIL_02,
                                        class t_TAIL_03,
                                        class t_TAIL_04>
struct Variant_VariantAlternativeImpl<t_INDEX, t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04>
: Variant_VariantAlternativeImpl<t_INDEX - 1, t_TAIL_01,
                                              t_TAIL_02,
                                              t_TAIL_03,
                                              t_TAIL_04> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 5
template <size_t t_INDEX, class t_HEAD, class t_TAIL_01,
                                        class t_TAIL_02,
                                        class t_TAIL_03,
                                        class t_TAIL_04,
                                        class t_TAIL_05>
struct Variant_VariantAlternativeImpl<t_INDEX, t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05>
: Variant_VariantAlternativeImpl<t_INDEX - 1, t_TAIL_01,
                                              t_TAIL_02,
                                              t_TAIL_03,
                                              t_TAIL_04,
                                              t_TAIL_05> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 6
template <size_t t_INDEX, class t_HEAD, class t_TAIL_01,
                                        class t_TAIL_02,
                                        class t_TAIL_03,
                                        class t_TAIL_04,
                                        class t_TAIL_05,
                                        class t_TAIL_06>
struct Variant_VariantAlternativeImpl<t_INDEX, t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06>
: Variant_VariantAlternativeImpl<t_INDEX - 1, t_TAIL_01,
                                              t_TAIL_02,
                                              t_TAIL_03,
                                              t_TAIL_04,
                                              t_TAIL_05,
                                              t_TAIL_06> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 7
template <size_t t_INDEX, class t_HEAD, class t_TAIL_01,
                                        class t_TAIL_02,
                                        class t_TAIL_03,
                                        class t_TAIL_04,
                                        class t_TAIL_05,
                                        class t_TAIL_06,
                                        class t_TAIL_07>
struct Variant_VariantAlternativeImpl<t_INDEX, t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07>
: Variant_VariantAlternativeImpl<t_INDEX - 1, t_TAIL_01,
                                              t_TAIL_02,
                                              t_TAIL_03,
                                              t_TAIL_04,
                                              t_TAIL_05,
                                              t_TAIL_06,
                                              t_TAIL_07> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 8
template <size_t t_INDEX, class t_HEAD, class t_TAIL_01,
                                        class t_TAIL_02,
                                        class t_TAIL_03,
                                        class t_TAIL_04,
                                        class t_TAIL_05,
                                        class t_TAIL_06,
                                        class t_TAIL_07,
                                        class t_TAIL_08>
struct Variant_VariantAlternativeImpl<t_INDEX, t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08>
: Variant_VariantAlternativeImpl<t_INDEX - 1, t_TAIL_01,
                                              t_TAIL_02,
                                              t_TAIL_03,
                                              t_TAIL_04,
                                              t_TAIL_05,
                                              t_TAIL_06,
                                              t_TAIL_07,
                                              t_TAIL_08> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 9
template <size_t t_INDEX, class t_HEAD, class t_TAIL_01,
                                        class t_TAIL_02,
                                        class t_TAIL_03,
                                        class t_TAIL_04,
                                        class t_TAIL_05,
                                        class t_TAIL_06,
                                        class t_TAIL_07,
                                        class t_TAIL_08,
                                        class t_TAIL_09>
struct Variant_VariantAlternativeImpl<t_INDEX, t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09>
: Variant_VariantAlternativeImpl<t_INDEX - 1, t_TAIL_01,
                                              t_TAIL_02,
                                              t_TAIL_03,
                                              t_TAIL_04,
                                              t_TAIL_05,
                                              t_TAIL_06,
                                              t_TAIL_07,
                                              t_TAIL_08,
                                              t_TAIL_09> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 10
template <size_t t_INDEX, class t_HEAD, class t_TAIL_01,
                                        class t_TAIL_02,
                                        class t_TAIL_03,
                                        class t_TAIL_04,
                                        class t_TAIL_05,
                                        class t_TAIL_06,
                                        class t_TAIL_07,
                                        class t_TAIL_08,
                                        class t_TAIL_09,
                                        class t_TAIL_10>
struct Variant_VariantAlternativeImpl<t_INDEX, t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10>
: Variant_VariantAlternativeImpl<t_INDEX - 1, t_TAIL_01,
                                              t_TAIL_02,
                                              t_TAIL_03,
                                              t_TAIL_04,
                                              t_TAIL_05,
                                              t_TAIL_06,
                                              t_TAIL_07,
                                              t_TAIL_08,
                                              t_TAIL_09,
                                              t_TAIL_10> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 11
template <size_t t_INDEX, class t_HEAD, class t_TAIL_01,
                                        class t_TAIL_02,
                                        class t_TAIL_03,
                                        class t_TAIL_04,
                                        class t_TAIL_05,
                                        class t_TAIL_06,
                                        class t_TAIL_07,
                                        class t_TAIL_08,
                                        class t_TAIL_09,
                                        class t_TAIL_10,
                                        class t_TAIL_11>
struct Variant_VariantAlternativeImpl<t_INDEX, t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11>
: Variant_VariantAlternativeImpl<t_INDEX - 1, t_TAIL_01,
                                              t_TAIL_02,
                                              t_TAIL_03,
                                              t_TAIL_04,
                                              t_TAIL_05,
                                              t_TAIL_06,
                                              t_TAIL_07,
                                              t_TAIL_08,
                                              t_TAIL_09,
                                              t_TAIL_10,
                                              t_TAIL_11> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 12
template <size_t t_INDEX, class t_HEAD, class t_TAIL_01,
                                        class t_TAIL_02,
                                        class t_TAIL_03,
                                        class t_TAIL_04,
                                        class t_TAIL_05,
                                        class t_TAIL_06,
                                        class t_TAIL_07,
                                        class t_TAIL_08,
                                        class t_TAIL_09,
                                        class t_TAIL_10,
                                        class t_TAIL_11,
                                        class t_TAIL_12>
struct Variant_VariantAlternativeImpl<t_INDEX, t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11,
                                                       t_TAIL_12>
: Variant_VariantAlternativeImpl<t_INDEX - 1, t_TAIL_01,
                                              t_TAIL_02,
                                              t_TAIL_03,
                                              t_TAIL_04,
                                              t_TAIL_05,
                                              t_TAIL_06,
                                              t_TAIL_07,
                                              t_TAIL_08,
                                              t_TAIL_09,
                                              t_TAIL_10,
                                              t_TAIL_11,
                                              t_TAIL_12> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 13
template <size_t t_INDEX, class t_HEAD, class t_TAIL_01,
                                        class t_TAIL_02,
                                        class t_TAIL_03,
                                        class t_TAIL_04,
                                        class t_TAIL_05,
                                        class t_TAIL_06,
                                        class t_TAIL_07,
                                        class t_TAIL_08,
                                        class t_TAIL_09,
                                        class t_TAIL_10,
                                        class t_TAIL_11,
                                        class t_TAIL_12,
                                        class t_TAIL_13>
struct Variant_VariantAlternativeImpl<t_INDEX, t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11,
                                                       t_TAIL_12,
                                                       t_TAIL_13>
: Variant_VariantAlternativeImpl<t_INDEX - 1, t_TAIL_01,
                                              t_TAIL_02,
                                              t_TAIL_03,
                                              t_TAIL_04,
                                              t_TAIL_05,
                                              t_TAIL_06,
                                              t_TAIL_07,
                                              t_TAIL_08,
                                              t_TAIL_09,
                                              t_TAIL_10,
                                              t_TAIL_11,
                                              t_TAIL_12,
                                              t_TAIL_13> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 14
template <size_t t_INDEX, class t_HEAD, class t_TAIL_01,
                                        class t_TAIL_02,
                                        class t_TAIL_03,
                                        class t_TAIL_04,
                                        class t_TAIL_05,
                                        class t_TAIL_06,
                                        class t_TAIL_07,
                                        class t_TAIL_08,
                                        class t_TAIL_09,
                                        class t_TAIL_10,
                                        class t_TAIL_11,
                                        class t_TAIL_12,
                                        class t_TAIL_13,
                                        class t_TAIL_14>
struct Variant_VariantAlternativeImpl<t_INDEX, t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11,
                                                       t_TAIL_12,
                                                       t_TAIL_13,
                                                       t_TAIL_14>
: Variant_VariantAlternativeImpl<t_INDEX - 1, t_TAIL_01,
                                              t_TAIL_02,
                                              t_TAIL_03,
                                              t_TAIL_04,
                                              t_TAIL_05,
                                              t_TAIL_06,
                                              t_TAIL_07,
                                              t_TAIL_08,
                                              t_TAIL_09,
                                              t_TAIL_10,
                                              t_TAIL_11,
                                              t_TAIL_12,
                                              t_TAIL_13,
                                              t_TAIL_14> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 15
template <size_t t_INDEX, class t_HEAD, class t_TAIL_01,
                                        class t_TAIL_02,
                                        class t_TAIL_03,
                                        class t_TAIL_04,
                                        class t_TAIL_05,
                                        class t_TAIL_06,
                                        class t_TAIL_07,
                                        class t_TAIL_08,
                                        class t_TAIL_09,
                                        class t_TAIL_10,
                                        class t_TAIL_11,
                                        class t_TAIL_12,
                                        class t_TAIL_13,
                                        class t_TAIL_14,
                                        class t_TAIL_15>
struct Variant_VariantAlternativeImpl<t_INDEX, t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11,
                                                       t_TAIL_12,
                                                       t_TAIL_13,
                                                       t_TAIL_14,
                                                       t_TAIL_15>
: Variant_VariantAlternativeImpl<t_INDEX - 1, t_TAIL_01,
                                              t_TAIL_02,
                                              t_TAIL_03,
                                              t_TAIL_04,
                                              t_TAIL_05,
                                              t_TAIL_06,
                                              t_TAIL_07,
                                              t_TAIL_08,
                                              t_TAIL_09,
                                              t_TAIL_10,
                                              t_TAIL_11,
                                              t_TAIL_12,
                                              t_TAIL_13,
                                              t_TAIL_14,
                                              t_TAIL_15> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 16
template <size_t t_INDEX, class t_HEAD, class t_TAIL_01,
                                        class t_TAIL_02,
                                        class t_TAIL_03,
                                        class t_TAIL_04,
                                        class t_TAIL_05,
                                        class t_TAIL_06,
                                        class t_TAIL_07,
                                        class t_TAIL_08,
                                        class t_TAIL_09,
                                        class t_TAIL_10,
                                        class t_TAIL_11,
                                        class t_TAIL_12,
                                        class t_TAIL_13,
                                        class t_TAIL_14,
                                        class t_TAIL_15,
                                        class t_TAIL_16>
struct Variant_VariantAlternativeImpl<t_INDEX, t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11,
                                                       t_TAIL_12,
                                                       t_TAIL_13,
                                                       t_TAIL_14,
                                                       t_TAIL_15,
                                                       t_TAIL_16>
: Variant_VariantAlternativeImpl<t_INDEX - 1, t_TAIL_01,
                                              t_TAIL_02,
                                              t_TAIL_03,
                                              t_TAIL_04,
                                              t_TAIL_05,
                                              t_TAIL_06,
                                              t_TAIL_07,
                                              t_TAIL_08,
                                              t_TAIL_09,
                                              t_TAIL_10,
                                              t_TAIL_11,
                                              t_TAIL_12,
                                              t_TAIL_13,
                                              t_TAIL_14,
                                              t_TAIL_15,
                                              t_TAIL_16> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 17
template <size_t t_INDEX, class t_HEAD, class t_TAIL_01,
                                        class t_TAIL_02,
                                        class t_TAIL_03,
                                        class t_TAIL_04,
                                        class t_TAIL_05,
                                        class t_TAIL_06,
                                        class t_TAIL_07,
                                        class t_TAIL_08,
                                        class t_TAIL_09,
                                        class t_TAIL_10,
                                        class t_TAIL_11,
                                        class t_TAIL_12,
                                        class t_TAIL_13,
                                        class t_TAIL_14,
                                        class t_TAIL_15,
                                        class t_TAIL_16,
                                        class t_TAIL_17>
struct Variant_VariantAlternativeImpl<t_INDEX, t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11,
                                                       t_TAIL_12,
                                                       t_TAIL_13,
                                                       t_TAIL_14,
                                                       t_TAIL_15,
                                                       t_TAIL_16,
                                                       t_TAIL_17>
: Variant_VariantAlternativeImpl<t_INDEX - 1, t_TAIL_01,
                                              t_TAIL_02,
                                              t_TAIL_03,
                                              t_TAIL_04,
                                              t_TAIL_05,
                                              t_TAIL_06,
                                              t_TAIL_07,
                                              t_TAIL_08,
                                              t_TAIL_09,
                                              t_TAIL_10,
                                              t_TAIL_11,
                                              t_TAIL_12,
                                              t_TAIL_13,
                                              t_TAIL_14,
                                              t_TAIL_15,
                                              t_TAIL_16,
                                              t_TAIL_17> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 18
template <size_t t_INDEX, class t_HEAD, class t_TAIL_01,
                                        class t_TAIL_02,
                                        class t_TAIL_03,
                                        class t_TAIL_04,
                                        class t_TAIL_05,
                                        class t_TAIL_06,
                                        class t_TAIL_07,
                                        class t_TAIL_08,
                                        class t_TAIL_09,
                                        class t_TAIL_10,
                                        class t_TAIL_11,
                                        class t_TAIL_12,
                                        class t_TAIL_13,
                                        class t_TAIL_14,
                                        class t_TAIL_15,
                                        class t_TAIL_16,
                                        class t_TAIL_17,
                                        class t_TAIL_18>
struct Variant_VariantAlternativeImpl<t_INDEX, t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11,
                                                       t_TAIL_12,
                                                       t_TAIL_13,
                                                       t_TAIL_14,
                                                       t_TAIL_15,
                                                       t_TAIL_16,
                                                       t_TAIL_17,
                                                       t_TAIL_18>
: Variant_VariantAlternativeImpl<t_INDEX - 1, t_TAIL_01,
                                              t_TAIL_02,
                                              t_TAIL_03,
                                              t_TAIL_04,
                                              t_TAIL_05,
                                              t_TAIL_06,
                                              t_TAIL_07,
                                              t_TAIL_08,
                                              t_TAIL_09,
                                              t_TAIL_10,
                                              t_TAIL_11,
                                              t_TAIL_12,
                                              t_TAIL_13,
                                              t_TAIL_14,
                                              t_TAIL_15,
                                              t_TAIL_16,
                                              t_TAIL_17,
                                              t_TAIL_18> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 18
 
 
template <size_t t_INDEX>
struct Variant_VariantAlternativeImpl<t_INDEX, BSLSTL_VARIANT_NOT_A_TYPE> {
};
 
template <>
struct Variant_VariantAlternativeImpl<0, BSLSTL_VARIANT_NOT_A_TYPE> {
};
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 0
template <class t_HEAD>
struct Variant_VariantAlternativeImpl<0, t_HEAD> {
    typedef t_HEAD type;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 1
template <class t_HEAD, class t_TAIL_01>
struct Variant_VariantAlternativeImpl<0, t_HEAD, t_TAIL_01> {
    typedef t_HEAD type;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
struct Variant_VariantAlternativeImpl<0, t_HEAD, t_TAIL_01,
                                                 t_TAIL_02> {
    typedef t_HEAD type;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
struct Variant_VariantAlternativeImpl<0, t_HEAD, t_TAIL_01,
                                                 t_TAIL_02,
                                                 t_TAIL_03> {
    typedef t_HEAD type;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
struct Variant_VariantAlternativeImpl<0, t_HEAD, t_TAIL_01,
                                                 t_TAIL_02,
                                                 t_TAIL_03,
                                                 t_TAIL_04> {
    typedef t_HEAD type;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
struct Variant_VariantAlternativeImpl<0, t_HEAD, t_TAIL_01,
                                                 t_TAIL_02,
                                                 t_TAIL_03,
                                                 t_TAIL_04,
                                                 t_TAIL_05> {
    typedef t_HEAD type;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
struct Variant_VariantAlternativeImpl<0, t_HEAD, t_TAIL_01,
                                                 t_TAIL_02,
                                                 t_TAIL_03,
                                                 t_TAIL_04,
                                                 t_TAIL_05,
                                                 t_TAIL_06> {
    typedef t_HEAD type;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
struct Variant_VariantAlternativeImpl<0, t_HEAD, t_TAIL_01,
                                                 t_TAIL_02,
                                                 t_TAIL_03,
                                                 t_TAIL_04,
                                                 t_TAIL_05,
                                                 t_TAIL_06,
                                                 t_TAIL_07> {
    typedef t_HEAD type;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
struct Variant_VariantAlternativeImpl<0, t_HEAD, t_TAIL_01,
                                                 t_TAIL_02,
                                                 t_TAIL_03,
                                                 t_TAIL_04,
                                                 t_TAIL_05,
                                                 t_TAIL_06,
                                                 t_TAIL_07,
                                                 t_TAIL_08> {
    typedef t_HEAD type;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
struct Variant_VariantAlternativeImpl<0, t_HEAD, t_TAIL_01,
                                                 t_TAIL_02,
                                                 t_TAIL_03,
                                                 t_TAIL_04,
                                                 t_TAIL_05,
                                                 t_TAIL_06,
                                                 t_TAIL_07,
                                                 t_TAIL_08,
                                                 t_TAIL_09> {
    typedef t_HEAD type;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
struct Variant_VariantAlternativeImpl<0, t_HEAD, t_TAIL_01,
                                                 t_TAIL_02,
                                                 t_TAIL_03,
                                                 t_TAIL_04,
                                                 t_TAIL_05,
                                                 t_TAIL_06,
                                                 t_TAIL_07,
                                                 t_TAIL_08,
                                                 t_TAIL_09,
                                                 t_TAIL_10> {
    typedef t_HEAD type;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
struct Variant_VariantAlternativeImpl<0, t_HEAD, t_TAIL_01,
                                                 t_TAIL_02,
                                                 t_TAIL_03,
                                                 t_TAIL_04,
                                                 t_TAIL_05,
                                                 t_TAIL_06,
                                                 t_TAIL_07,
                                                 t_TAIL_08,
                                                 t_TAIL_09,
                                                 t_TAIL_10,
                                                 t_TAIL_11> {
    typedef t_HEAD type;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
struct Variant_VariantAlternativeImpl<0, t_HEAD, t_TAIL_01,
                                                 t_TAIL_02,
                                                 t_TAIL_03,
                                                 t_TAIL_04,
                                                 t_TAIL_05,
                                                 t_TAIL_06,
                                                 t_TAIL_07,
                                                 t_TAIL_08,
                                                 t_TAIL_09,
                                                 t_TAIL_10,
                                                 t_TAIL_11,
                                                 t_TAIL_12> {
    typedef t_HEAD type;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
struct Variant_VariantAlternativeImpl<0, t_HEAD, t_TAIL_01,
                                                 t_TAIL_02,
                                                 t_TAIL_03,
                                                 t_TAIL_04,
                                                 t_TAIL_05,
                                                 t_TAIL_06,
                                                 t_TAIL_07,
                                                 t_TAIL_08,
                                                 t_TAIL_09,
                                                 t_TAIL_10,
                                                 t_TAIL_11,
                                                 t_TAIL_12,
                                                 t_TAIL_13> {
    typedef t_HEAD type;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
struct Variant_VariantAlternativeImpl<0, t_HEAD, t_TAIL_01,
                                                 t_TAIL_02,
                                                 t_TAIL_03,
                                                 t_TAIL_04,
                                                 t_TAIL_05,
                                                 t_TAIL_06,
                                                 t_TAIL_07,
                                                 t_TAIL_08,
                                                 t_TAIL_09,
                                                 t_TAIL_10,
                                                 t_TAIL_11,
                                                 t_TAIL_12,
                                                 t_TAIL_13,
                                                 t_TAIL_14> {
    typedef t_HEAD type;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
struct Variant_VariantAlternativeImpl<0, t_HEAD, t_TAIL_01,
                                                 t_TAIL_02,
                                                 t_TAIL_03,
                                                 t_TAIL_04,
                                                 t_TAIL_05,
                                                 t_TAIL_06,
                                                 t_TAIL_07,
                                                 t_TAIL_08,
                                                 t_TAIL_09,
                                                 t_TAIL_10,
                                                 t_TAIL_11,
                                                 t_TAIL_12,
                                                 t_TAIL_13,
                                                 t_TAIL_14,
                                                 t_TAIL_15> {
    typedef t_HEAD type;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
struct Variant_VariantAlternativeImpl<0, t_HEAD, t_TAIL_01,
                                                 t_TAIL_02,
                                                 t_TAIL_03,
                                                 t_TAIL_04,
                                                 t_TAIL_05,
                                                 t_TAIL_06,
                                                 t_TAIL_07,
                                                 t_TAIL_08,
                                                 t_TAIL_09,
                                                 t_TAIL_10,
                                                 t_TAIL_11,
                                                 t_TAIL_12,
                                                 t_TAIL_13,
                                                 t_TAIL_14,
                                                 t_TAIL_15,
                                                 t_TAIL_16> {
    typedef t_HEAD type;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
struct Variant_VariantAlternativeImpl<0, t_HEAD, t_TAIL_01,
                                                 t_TAIL_02,
                                                 t_TAIL_03,
                                                 t_TAIL_04,
                                                 t_TAIL_05,
                                                 t_TAIL_06,
                                                 t_TAIL_07,
                                                 t_TAIL_08,
                                                 t_TAIL_09,
                                                 t_TAIL_10,
                                                 t_TAIL_11,
                                                 t_TAIL_12,
                                                 t_TAIL_13,
                                                 t_TAIL_14,
                                                 t_TAIL_15,
                                                 t_TAIL_16,
                                                 t_TAIL_17> {
    typedef t_HEAD type;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
struct Variant_VariantAlternativeImpl<0, t_HEAD, t_TAIL_01,
                                                 t_TAIL_02,
                                                 t_TAIL_03,
                                                 t_TAIL_04,
                                                 t_TAIL_05,
                                                 t_TAIL_06,
                                                 t_TAIL_07,
                                                 t_TAIL_08,
                                                 t_TAIL_09,
                                                 t_TAIL_10,
                                                 t_TAIL_11,
                                                 t_TAIL_12,
                                                 t_TAIL_13,
                                                 t_TAIL_14,
                                                 t_TAIL_15,
                                                 t_TAIL_16,
                                                 t_TAIL_17,
                                                 t_TAIL_18> {
    typedef t_HEAD type;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 0
template <size_t t_INDEX, class t_HEAD>
struct variant_alternative<t_INDEX, variant<t_HEAD> >
: Variant_VariantAlternativeImpl<t_INDEX, t_HEAD> {
    BSLMF_ASSERT((t_INDEX <
                  bsl::variant_size<variant<t_HEAD> >::value));
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 1
template <size_t t_INDEX, class t_HEAD, class t_TAIL_01>
struct variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01> >
: Variant_VariantAlternativeImpl<t_INDEX, t_HEAD, t_TAIL_01> {
    BSLMF_ASSERT((t_INDEX <
                  bsl::variant_size<variant<t_HEAD, t_TAIL_01> >::value));
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 2
template <size_t t_INDEX, class t_HEAD, class t_TAIL_01,
                                        class t_TAIL_02>
struct variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02> >
: Variant_VariantAlternativeImpl<t_INDEX, t_HEAD, t_TAIL_01,
                                                  t_TAIL_02> {
    BSLMF_ASSERT((t_INDEX <
                  bsl::variant_size<variant<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02> >::value));
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 3
template <size_t t_INDEX, class t_HEAD, class t_TAIL_01,
                                        class t_TAIL_02,
                                        class t_TAIL_03>
struct variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03> >
: Variant_VariantAlternativeImpl<t_INDEX, t_HEAD, t_TAIL_01,
                                                  t_TAIL_02,
                                                  t_TAIL_03> {
    BSLMF_ASSERT((t_INDEX <
                  bsl::variant_size<variant<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03> >::value));
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 4
template <size_t t_INDEX, class t_HEAD, class t_TAIL_01,
                                        class t_TAIL_02,
                                        class t_TAIL_03,
                                        class t_TAIL_04>
struct variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04> >
: Variant_VariantAlternativeImpl<t_INDEX, t_HEAD, t_TAIL_01,
                                                  t_TAIL_02,
                                                  t_TAIL_03,
                                                  t_TAIL_04> {
    BSLMF_ASSERT((t_INDEX <
                  bsl::variant_size<variant<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04> >::value));
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 5
template <size_t t_INDEX, class t_HEAD, class t_TAIL_01,
                                        class t_TAIL_02,
                                        class t_TAIL_03,
                                        class t_TAIL_04,
                                        class t_TAIL_05>
struct variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05> >
: Variant_VariantAlternativeImpl<t_INDEX, t_HEAD, t_TAIL_01,
                                                  t_TAIL_02,
                                                  t_TAIL_03,
                                                  t_TAIL_04,
                                                  t_TAIL_05> {
    BSLMF_ASSERT((t_INDEX <
                  bsl::variant_size<variant<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05> >::value));
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 6
template <size_t t_INDEX, class t_HEAD, class t_TAIL_01,
                                        class t_TAIL_02,
                                        class t_TAIL_03,
                                        class t_TAIL_04,
                                        class t_TAIL_05,
                                        class t_TAIL_06>
struct variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06> >
: Variant_VariantAlternativeImpl<t_INDEX, t_HEAD, t_TAIL_01,
                                                  t_TAIL_02,
                                                  t_TAIL_03,
                                                  t_TAIL_04,
                                                  t_TAIL_05,
                                                  t_TAIL_06> {
    BSLMF_ASSERT((t_INDEX <
                  bsl::variant_size<variant<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06> >::value));
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 7
template <size_t t_INDEX, class t_HEAD, class t_TAIL_01,
                                        class t_TAIL_02,
                                        class t_TAIL_03,
                                        class t_TAIL_04,
                                        class t_TAIL_05,
                                        class t_TAIL_06,
                                        class t_TAIL_07>
struct variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06,
                                                    t_TAIL_07> >
: Variant_VariantAlternativeImpl<t_INDEX, t_HEAD, t_TAIL_01,
                                                  t_TAIL_02,
                                                  t_TAIL_03,
                                                  t_TAIL_04,
                                                  t_TAIL_05,
                                                  t_TAIL_06,
                                                  t_TAIL_07> {
    BSLMF_ASSERT((t_INDEX <
                  bsl::variant_size<variant<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06,
                                                    t_TAIL_07> >::value));
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 8
template <size_t t_INDEX, class t_HEAD, class t_TAIL_01,
                                        class t_TAIL_02,
                                        class t_TAIL_03,
                                        class t_TAIL_04,
                                        class t_TAIL_05,
                                        class t_TAIL_06,
                                        class t_TAIL_07,
                                        class t_TAIL_08>
struct variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06,
                                                    t_TAIL_07,
                                                    t_TAIL_08> >
: Variant_VariantAlternativeImpl<t_INDEX, t_HEAD, t_TAIL_01,
                                                  t_TAIL_02,
                                                  t_TAIL_03,
                                                  t_TAIL_04,
                                                  t_TAIL_05,
                                                  t_TAIL_06,
                                                  t_TAIL_07,
                                                  t_TAIL_08> {
    BSLMF_ASSERT((t_INDEX <
                  bsl::variant_size<variant<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06,
                                                    t_TAIL_07,
                                                    t_TAIL_08> >::value));
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 9
template <size_t t_INDEX, class t_HEAD, class t_TAIL_01,
                                        class t_TAIL_02,
                                        class t_TAIL_03,
                                        class t_TAIL_04,
                                        class t_TAIL_05,
                                        class t_TAIL_06,
                                        class t_TAIL_07,
                                        class t_TAIL_08,
                                        class t_TAIL_09>
struct variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06,
                                                    t_TAIL_07,
                                                    t_TAIL_08,
                                                    t_TAIL_09> >
: Variant_VariantAlternativeImpl<t_INDEX, t_HEAD, t_TAIL_01,
                                                  t_TAIL_02,
                                                  t_TAIL_03,
                                                  t_TAIL_04,
                                                  t_TAIL_05,
                                                  t_TAIL_06,
                                                  t_TAIL_07,
                                                  t_TAIL_08,
                                                  t_TAIL_09> {
    BSLMF_ASSERT((t_INDEX <
                  bsl::variant_size<variant<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06,
                                                    t_TAIL_07,
                                                    t_TAIL_08,
                                                    t_TAIL_09> >::value));
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 10
template <size_t t_INDEX, class t_HEAD, class t_TAIL_01,
                                        class t_TAIL_02,
                                        class t_TAIL_03,
                                        class t_TAIL_04,
                                        class t_TAIL_05,
                                        class t_TAIL_06,
                                        class t_TAIL_07,
                                        class t_TAIL_08,
                                        class t_TAIL_09,
                                        class t_TAIL_10>
struct variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06,
                                                    t_TAIL_07,
                                                    t_TAIL_08,
                                                    t_TAIL_09,
                                                    t_TAIL_10> >
: Variant_VariantAlternativeImpl<t_INDEX, t_HEAD, t_TAIL_01,
                                                  t_TAIL_02,
                                                  t_TAIL_03,
                                                  t_TAIL_04,
                                                  t_TAIL_05,
                                                  t_TAIL_06,
                                                  t_TAIL_07,
                                                  t_TAIL_08,
                                                  t_TAIL_09,
                                                  t_TAIL_10> {
    BSLMF_ASSERT((t_INDEX <
                  bsl::variant_size<variant<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06,
                                                    t_TAIL_07,
                                                    t_TAIL_08,
                                                    t_TAIL_09,
                                                    t_TAIL_10> >::value));
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 11
template <size_t t_INDEX, class t_HEAD, class t_TAIL_01,
                                        class t_TAIL_02,
                                        class t_TAIL_03,
                                        class t_TAIL_04,
                                        class t_TAIL_05,
                                        class t_TAIL_06,
                                        class t_TAIL_07,
                                        class t_TAIL_08,
                                        class t_TAIL_09,
                                        class t_TAIL_10,
                                        class t_TAIL_11>
struct variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06,
                                                    t_TAIL_07,
                                                    t_TAIL_08,
                                                    t_TAIL_09,
                                                    t_TAIL_10,
                                                    t_TAIL_11> >
: Variant_VariantAlternativeImpl<t_INDEX, t_HEAD, t_TAIL_01,
                                                  t_TAIL_02,
                                                  t_TAIL_03,
                                                  t_TAIL_04,
                                                  t_TAIL_05,
                                                  t_TAIL_06,
                                                  t_TAIL_07,
                                                  t_TAIL_08,
                                                  t_TAIL_09,
                                                  t_TAIL_10,
                                                  t_TAIL_11> {
    BSLMF_ASSERT((t_INDEX <
                  bsl::variant_size<variant<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06,
                                                    t_TAIL_07,
                                                    t_TAIL_08,
                                                    t_TAIL_09,
                                                    t_TAIL_10,
                                                    t_TAIL_11> >::value));
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 12
template <size_t t_INDEX, class t_HEAD, class t_TAIL_01,
                                        class t_TAIL_02,
                                        class t_TAIL_03,
                                        class t_TAIL_04,
                                        class t_TAIL_05,
                                        class t_TAIL_06,
                                        class t_TAIL_07,
                                        class t_TAIL_08,
                                        class t_TAIL_09,
                                        class t_TAIL_10,
                                        class t_TAIL_11,
                                        class t_TAIL_12>
struct variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06,
                                                    t_TAIL_07,
                                                    t_TAIL_08,
                                                    t_TAIL_09,
                                                    t_TAIL_10,
                                                    t_TAIL_11,
                                                    t_TAIL_12> >
: Variant_VariantAlternativeImpl<t_INDEX, t_HEAD, t_TAIL_01,
                                                  t_TAIL_02,
                                                  t_TAIL_03,
                                                  t_TAIL_04,
                                                  t_TAIL_05,
                                                  t_TAIL_06,
                                                  t_TAIL_07,
                                                  t_TAIL_08,
                                                  t_TAIL_09,
                                                  t_TAIL_10,
                                                  t_TAIL_11,
                                                  t_TAIL_12> {
    BSLMF_ASSERT((t_INDEX <
                  bsl::variant_size<variant<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06,
                                                    t_TAIL_07,
                                                    t_TAIL_08,
                                                    t_TAIL_09,
                                                    t_TAIL_10,
                                                    t_TAIL_11,
                                                    t_TAIL_12> >::value));
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 13
template <size_t t_INDEX, class t_HEAD, class t_TAIL_01,
                                        class t_TAIL_02,
                                        class t_TAIL_03,
                                        class t_TAIL_04,
                                        class t_TAIL_05,
                                        class t_TAIL_06,
                                        class t_TAIL_07,
                                        class t_TAIL_08,
                                        class t_TAIL_09,
                                        class t_TAIL_10,
                                        class t_TAIL_11,
                                        class t_TAIL_12,
                                        class t_TAIL_13>
struct variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06,
                                                    t_TAIL_07,
                                                    t_TAIL_08,
                                                    t_TAIL_09,
                                                    t_TAIL_10,
                                                    t_TAIL_11,
                                                    t_TAIL_12,
                                                    t_TAIL_13> >
: Variant_VariantAlternativeImpl<t_INDEX, t_HEAD, t_TAIL_01,
                                                  t_TAIL_02,
                                                  t_TAIL_03,
                                                  t_TAIL_04,
                                                  t_TAIL_05,
                                                  t_TAIL_06,
                                                  t_TAIL_07,
                                                  t_TAIL_08,
                                                  t_TAIL_09,
                                                  t_TAIL_10,
                                                  t_TAIL_11,
                                                  t_TAIL_12,
                                                  t_TAIL_13> {
    BSLMF_ASSERT((t_INDEX <
                  bsl::variant_size<variant<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06,
                                                    t_TAIL_07,
                                                    t_TAIL_08,
                                                    t_TAIL_09,
                                                    t_TAIL_10,
                                                    t_TAIL_11,
                                                    t_TAIL_12,
                                                    t_TAIL_13> >::value));
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 14
template <size_t t_INDEX, class t_HEAD, class t_TAIL_01,
                                        class t_TAIL_02,
                                        class t_TAIL_03,
                                        class t_TAIL_04,
                                        class t_TAIL_05,
                                        class t_TAIL_06,
                                        class t_TAIL_07,
                                        class t_TAIL_08,
                                        class t_TAIL_09,
                                        class t_TAIL_10,
                                        class t_TAIL_11,
                                        class t_TAIL_12,
                                        class t_TAIL_13,
                                        class t_TAIL_14>
struct variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06,
                                                    t_TAIL_07,
                                                    t_TAIL_08,
                                                    t_TAIL_09,
                                                    t_TAIL_10,
                                                    t_TAIL_11,
                                                    t_TAIL_12,
                                                    t_TAIL_13,
                                                    t_TAIL_14> >
: Variant_VariantAlternativeImpl<t_INDEX, t_HEAD, t_TAIL_01,
                                                  t_TAIL_02,
                                                  t_TAIL_03,
                                                  t_TAIL_04,
                                                  t_TAIL_05,
                                                  t_TAIL_06,
                                                  t_TAIL_07,
                                                  t_TAIL_08,
                                                  t_TAIL_09,
                                                  t_TAIL_10,
                                                  t_TAIL_11,
                                                  t_TAIL_12,
                                                  t_TAIL_13,
                                                  t_TAIL_14> {
    BSLMF_ASSERT((t_INDEX <
                  bsl::variant_size<variant<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06,
                                                    t_TAIL_07,
                                                    t_TAIL_08,
                                                    t_TAIL_09,
                                                    t_TAIL_10,
                                                    t_TAIL_11,
                                                    t_TAIL_12,
                                                    t_TAIL_13,
                                                    t_TAIL_14> >::value));
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 15
template <size_t t_INDEX, class t_HEAD, class t_TAIL_01,
                                        class t_TAIL_02,
                                        class t_TAIL_03,
                                        class t_TAIL_04,
                                        class t_TAIL_05,
                                        class t_TAIL_06,
                                        class t_TAIL_07,
                                        class t_TAIL_08,
                                        class t_TAIL_09,
                                        class t_TAIL_10,
                                        class t_TAIL_11,
                                        class t_TAIL_12,
                                        class t_TAIL_13,
                                        class t_TAIL_14,
                                        class t_TAIL_15>
struct variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06,
                                                    t_TAIL_07,
                                                    t_TAIL_08,
                                                    t_TAIL_09,
                                                    t_TAIL_10,
                                                    t_TAIL_11,
                                                    t_TAIL_12,
                                                    t_TAIL_13,
                                                    t_TAIL_14,
                                                    t_TAIL_15> >
: Variant_VariantAlternativeImpl<t_INDEX, t_HEAD, t_TAIL_01,
                                                  t_TAIL_02,
                                                  t_TAIL_03,
                                                  t_TAIL_04,
                                                  t_TAIL_05,
                                                  t_TAIL_06,
                                                  t_TAIL_07,
                                                  t_TAIL_08,
                                                  t_TAIL_09,
                                                  t_TAIL_10,
                                                  t_TAIL_11,
                                                  t_TAIL_12,
                                                  t_TAIL_13,
                                                  t_TAIL_14,
                                                  t_TAIL_15> {
    BSLMF_ASSERT((t_INDEX <
                  bsl::variant_size<variant<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06,
                                                    t_TAIL_07,
                                                    t_TAIL_08,
                                                    t_TAIL_09,
                                                    t_TAIL_10,
                                                    t_TAIL_11,
                                                    t_TAIL_12,
                                                    t_TAIL_13,
                                                    t_TAIL_14,
                                                    t_TAIL_15> >::value));
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 16
template <size_t t_INDEX, class t_HEAD, class t_TAIL_01,
                                        class t_TAIL_02,
                                        class t_TAIL_03,
                                        class t_TAIL_04,
                                        class t_TAIL_05,
                                        class t_TAIL_06,
                                        class t_TAIL_07,
                                        class t_TAIL_08,
                                        class t_TAIL_09,
                                        class t_TAIL_10,
                                        class t_TAIL_11,
                                        class t_TAIL_12,
                                        class t_TAIL_13,
                                        class t_TAIL_14,
                                        class t_TAIL_15,
                                        class t_TAIL_16>
struct variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06,
                                                    t_TAIL_07,
                                                    t_TAIL_08,
                                                    t_TAIL_09,
                                                    t_TAIL_10,
                                                    t_TAIL_11,
                                                    t_TAIL_12,
                                                    t_TAIL_13,
                                                    t_TAIL_14,
                                                    t_TAIL_15,
                                                    t_TAIL_16> >
: Variant_VariantAlternativeImpl<t_INDEX, t_HEAD, t_TAIL_01,
                                                  t_TAIL_02,
                                                  t_TAIL_03,
                                                  t_TAIL_04,
                                                  t_TAIL_05,
                                                  t_TAIL_06,
                                                  t_TAIL_07,
                                                  t_TAIL_08,
                                                  t_TAIL_09,
                                                  t_TAIL_10,
                                                  t_TAIL_11,
                                                  t_TAIL_12,
                                                  t_TAIL_13,
                                                  t_TAIL_14,
                                                  t_TAIL_15,
                                                  t_TAIL_16> {
    BSLMF_ASSERT((t_INDEX <
                  bsl::variant_size<variant<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06,
                                                    t_TAIL_07,
                                                    t_TAIL_08,
                                                    t_TAIL_09,
                                                    t_TAIL_10,
                                                    t_TAIL_11,
                                                    t_TAIL_12,
                                                    t_TAIL_13,
                                                    t_TAIL_14,
                                                    t_TAIL_15,
                                                    t_TAIL_16> >::value));
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 17
template <size_t t_INDEX, class t_HEAD, class t_TAIL_01,
                                        class t_TAIL_02,
                                        class t_TAIL_03,
                                        class t_TAIL_04,
                                        class t_TAIL_05,
                                        class t_TAIL_06,
                                        class t_TAIL_07,
                                        class t_TAIL_08,
                                        class t_TAIL_09,
                                        class t_TAIL_10,
                                        class t_TAIL_11,
                                        class t_TAIL_12,
                                        class t_TAIL_13,
                                        class t_TAIL_14,
                                        class t_TAIL_15,
                                        class t_TAIL_16,
                                        class t_TAIL_17>
struct variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06,
                                                    t_TAIL_07,
                                                    t_TAIL_08,
                                                    t_TAIL_09,
                                                    t_TAIL_10,
                                                    t_TAIL_11,
                                                    t_TAIL_12,
                                                    t_TAIL_13,
                                                    t_TAIL_14,
                                                    t_TAIL_15,
                                                    t_TAIL_16,
                                                    t_TAIL_17> >
: Variant_VariantAlternativeImpl<t_INDEX, t_HEAD, t_TAIL_01,
                                                  t_TAIL_02,
                                                  t_TAIL_03,
                                                  t_TAIL_04,
                                                  t_TAIL_05,
                                                  t_TAIL_06,
                                                  t_TAIL_07,
                                                  t_TAIL_08,
                                                  t_TAIL_09,
                                                  t_TAIL_10,
                                                  t_TAIL_11,
                                                  t_TAIL_12,
                                                  t_TAIL_13,
                                                  t_TAIL_14,
                                                  t_TAIL_15,
                                                  t_TAIL_16,
                                                  t_TAIL_17> {
    BSLMF_ASSERT((t_INDEX <
                  bsl::variant_size<variant<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06,
                                                    t_TAIL_07,
                                                    t_TAIL_08,
                                                    t_TAIL_09,
                                                    t_TAIL_10,
                                                    t_TAIL_11,
                                                    t_TAIL_12,
                                                    t_TAIL_13,
                                                    t_TAIL_14,
                                                    t_TAIL_15,
                                                    t_TAIL_16,
                                                    t_TAIL_17> >::value));
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 18
template <size_t t_INDEX, class t_HEAD, class t_TAIL_01,
                                        class t_TAIL_02,
                                        class t_TAIL_03,
                                        class t_TAIL_04,
                                        class t_TAIL_05,
                                        class t_TAIL_06,
                                        class t_TAIL_07,
                                        class t_TAIL_08,
                                        class t_TAIL_09,
                                        class t_TAIL_10,
                                        class t_TAIL_11,
                                        class t_TAIL_12,
                                        class t_TAIL_13,
                                        class t_TAIL_14,
                                        class t_TAIL_15,
                                        class t_TAIL_16,
                                        class t_TAIL_17,
                                        class t_TAIL_18>
struct variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06,
                                                    t_TAIL_07,
                                                    t_TAIL_08,
                                                    t_TAIL_09,
                                                    t_TAIL_10,
                                                    t_TAIL_11,
                                                    t_TAIL_12,
                                                    t_TAIL_13,
                                                    t_TAIL_14,
                                                    t_TAIL_15,
                                                    t_TAIL_16,
                                                    t_TAIL_17,
                                                    t_TAIL_18> >
: Variant_VariantAlternativeImpl<t_INDEX, t_HEAD, t_TAIL_01,
                                                  t_TAIL_02,
                                                  t_TAIL_03,
                                                  t_TAIL_04,
                                                  t_TAIL_05,
                                                  t_TAIL_06,
                                                  t_TAIL_07,
                                                  t_TAIL_08,
                                                  t_TAIL_09,
                                                  t_TAIL_10,
                                                  t_TAIL_11,
                                                  t_TAIL_12,
                                                  t_TAIL_13,
                                                  t_TAIL_14,
                                                  t_TAIL_15,
                                                  t_TAIL_16,
                                                  t_TAIL_17,
                                                  t_TAIL_18> {
    BSLMF_ASSERT((t_INDEX <
                  bsl::variant_size<variant<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06,
                                                    t_TAIL_07,
                                                    t_TAIL_08,
                                                    t_TAIL_09,
                                                    t_TAIL_10,
                                                    t_TAIL_11,
                                                    t_TAIL_12,
                                                    t_TAIL_13,
                                                    t_TAIL_14,
                                                    t_TAIL_15,
                                                    t_TAIL_16,
                                                    t_TAIL_17,
                                                    t_TAIL_18> >::value));
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 18
 
 
#ifdef BSLS_COMPILERFEATURES_SUPPORT_ALIAS_TEMPLATES
template <size_t t_INDEX, class t_TYPE>
using variant_alternative_t =
    typename variant_alternative<t_INDEX, t_TYPE>::type;
#endif
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 0
template <class t_HEAD>
void swap(bsl::variant<t_HEAD>& lhs,
          bsl::variant<t_HEAD>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 1
template <class t_HEAD, class t_TAIL_01>
void swap(bsl::variant<t_HEAD, t_TAIL_01>& lhs,
          bsl::variant<t_HEAD, t_TAIL_01>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
void swap(bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02>& lhs,
          bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
void swap(bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03>& lhs,
          bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
void swap(bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04>& lhs,
          bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
void swap(bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05>& lhs,
          bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
void swap(bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06>& lhs,
          bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
void swap(bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07>& lhs,
          bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
void swap(bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08>& lhs,
          bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
void swap(bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09>& lhs,
          bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
void swap(bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09,
                               t_TAIL_10>& lhs,
          bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09,
                               t_TAIL_10>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
void swap(bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09,
                               t_TAIL_10,
                               t_TAIL_11>& lhs,
          bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09,
                               t_TAIL_10,
                               t_TAIL_11>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
void swap(bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09,
                               t_TAIL_10,
                               t_TAIL_11,
                               t_TAIL_12>& lhs,
          bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09,
                               t_TAIL_10,
                               t_TAIL_11,
                               t_TAIL_12>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
void swap(bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09,
                               t_TAIL_10,
                               t_TAIL_11,
                               t_TAIL_12,
                               t_TAIL_13>& lhs,
          bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09,
                               t_TAIL_10,
                               t_TAIL_11,
                               t_TAIL_12,
                               t_TAIL_13>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
void swap(bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09,
                               t_TAIL_10,
                               t_TAIL_11,
                               t_TAIL_12,
                               t_TAIL_13,
                               t_TAIL_14>& lhs,
          bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09,
                               t_TAIL_10,
                               t_TAIL_11,
                               t_TAIL_12,
                               t_TAIL_13,
                               t_TAIL_14>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
void swap(bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09,
                               t_TAIL_10,
                               t_TAIL_11,
                               t_TAIL_12,
                               t_TAIL_13,
                               t_TAIL_14,
                               t_TAIL_15>& lhs,
          bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09,
                               t_TAIL_10,
                               t_TAIL_11,
                               t_TAIL_12,
                               t_TAIL_13,
                               t_TAIL_14,
                               t_TAIL_15>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
void swap(bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09,
                               t_TAIL_10,
                               t_TAIL_11,
                               t_TAIL_12,
                               t_TAIL_13,
                               t_TAIL_14,
                               t_TAIL_15,
                               t_TAIL_16>& lhs,
          bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09,
                               t_TAIL_10,
                               t_TAIL_11,
                               t_TAIL_12,
                               t_TAIL_13,
                               t_TAIL_14,
                               t_TAIL_15,
                               t_TAIL_16>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
void swap(bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09,
                               t_TAIL_10,
                               t_TAIL_11,
                               t_TAIL_12,
                               t_TAIL_13,
                               t_TAIL_14,
                               t_TAIL_15,
                               t_TAIL_16,
                               t_TAIL_17>& lhs,
          bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09,
                               t_TAIL_10,
                               t_TAIL_11,
                               t_TAIL_12,
                               t_TAIL_13,
                               t_TAIL_14,
                               t_TAIL_15,
                               t_TAIL_16,
                               t_TAIL_17>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
void swap(bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09,
                               t_TAIL_10,
                               t_TAIL_11,
                               t_TAIL_12,
                               t_TAIL_13,
                               t_TAIL_14,
                               t_TAIL_15,
                               t_TAIL_16,
                               t_TAIL_17,
                               t_TAIL_18>& lhs,
          bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09,
                               t_TAIL_10,
                               t_TAIL_11,
                               t_TAIL_12,
                               t_TAIL_13,
                               t_TAIL_14,
                               t_TAIL_15,
                               t_TAIL_16,
                               t_TAIL_17,
                               t_TAIL_18>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 18
 
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 0
template <class t_HASHALG, class t_HEAD>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD>& input);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 1
template <class t_HASHALG, class t_HEAD, class t_TAIL_01>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD, t_TAIL_01>& input);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 2
template <class t_HASHALG, class t_HEAD, class t_TAIL_01,
                                         class t_TAIL_02>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02>& input);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 3
template <class t_HASHALG, class t_HEAD, class t_TAIL_01,
                                         class t_TAIL_02,
                                         class t_TAIL_03>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03>& input);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 4
template <class t_HASHALG, class t_HEAD, class t_TAIL_01,
                                         class t_TAIL_02,
                                         class t_TAIL_03,
                                         class t_TAIL_04>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04>& input);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 5
template <class t_HASHALG, class t_HEAD, class t_TAIL_01,
                                         class t_TAIL_02,
                                         class t_TAIL_03,
                                         class t_TAIL_04,
                                         class t_TAIL_05>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05>& input);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 6
template <class t_HASHALG, class t_HEAD, class t_TAIL_01,
                                         class t_TAIL_02,
                                         class t_TAIL_03,
                                         class t_TAIL_04,
                                         class t_TAIL_05,
                                         class t_TAIL_06>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06>& input);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 7
template <class t_HASHALG, class t_HEAD, class t_TAIL_01,
                                         class t_TAIL_02,
                                         class t_TAIL_03,
                                         class t_TAIL_04,
                                         class t_TAIL_05,
                                         class t_TAIL_06,
                                         class t_TAIL_07>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07>& input);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 8
template <class t_HASHALG, class t_HEAD, class t_TAIL_01,
                                         class t_TAIL_02,
                                         class t_TAIL_03,
                                         class t_TAIL_04,
                                         class t_TAIL_05,
                                         class t_TAIL_06,
                                         class t_TAIL_07,
                                         class t_TAIL_08>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08>& input);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 9
template <class t_HASHALG, class t_HEAD, class t_TAIL_01,
                                         class t_TAIL_02,
                                         class t_TAIL_03,
                                         class t_TAIL_04,
                                         class t_TAIL_05,
                                         class t_TAIL_06,
                                         class t_TAIL_07,
                                         class t_TAIL_08,
                                         class t_TAIL_09>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09>& input);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 10
template <class t_HASHALG, class t_HEAD, class t_TAIL_01,
                                         class t_TAIL_02,
                                         class t_TAIL_03,
                                         class t_TAIL_04,
                                         class t_TAIL_05,
                                         class t_TAIL_06,
                                         class t_TAIL_07,
                                         class t_TAIL_08,
                                         class t_TAIL_09,
                                         class t_TAIL_10>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10>& input);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 11
template <class t_HASHALG, class t_HEAD, class t_TAIL_01,
                                         class t_TAIL_02,
                                         class t_TAIL_03,
                                         class t_TAIL_04,
                                         class t_TAIL_05,
                                         class t_TAIL_06,
                                         class t_TAIL_07,
                                         class t_TAIL_08,
                                         class t_TAIL_09,
                                         class t_TAIL_10,
                                         class t_TAIL_11>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11>& input);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 12
template <class t_HASHALG, class t_HEAD, class t_TAIL_01,
                                         class t_TAIL_02,
                                         class t_TAIL_03,
                                         class t_TAIL_04,
                                         class t_TAIL_05,
                                         class t_TAIL_06,
                                         class t_TAIL_07,
                                         class t_TAIL_08,
                                         class t_TAIL_09,
                                         class t_TAIL_10,
                                         class t_TAIL_11,
                                         class t_TAIL_12>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12>& input);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 13
template <class t_HASHALG, class t_HEAD, class t_TAIL_01,
                                         class t_TAIL_02,
                                         class t_TAIL_03,
                                         class t_TAIL_04,
                                         class t_TAIL_05,
                                         class t_TAIL_06,
                                         class t_TAIL_07,
                                         class t_TAIL_08,
                                         class t_TAIL_09,
                                         class t_TAIL_10,
                                         class t_TAIL_11,
                                         class t_TAIL_12,
                                         class t_TAIL_13>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13>& input);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 14
template <class t_HASHALG, class t_HEAD, class t_TAIL_01,
                                         class t_TAIL_02,
                                         class t_TAIL_03,
                                         class t_TAIL_04,
                                         class t_TAIL_05,
                                         class t_TAIL_06,
                                         class t_TAIL_07,
                                         class t_TAIL_08,
                                         class t_TAIL_09,
                                         class t_TAIL_10,
                                         class t_TAIL_11,
                                         class t_TAIL_12,
                                         class t_TAIL_13,
                                         class t_TAIL_14>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14>& input);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 15
template <class t_HASHALG, class t_HEAD, class t_TAIL_01,
                                         class t_TAIL_02,
                                         class t_TAIL_03,
                                         class t_TAIL_04,
                                         class t_TAIL_05,
                                         class t_TAIL_06,
                                         class t_TAIL_07,
                                         class t_TAIL_08,
                                         class t_TAIL_09,
                                         class t_TAIL_10,
                                         class t_TAIL_11,
                                         class t_TAIL_12,
                                         class t_TAIL_13,
                                         class t_TAIL_14,
                                         class t_TAIL_15>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15>& input);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 16
template <class t_HASHALG, class t_HEAD, class t_TAIL_01,
                                         class t_TAIL_02,
                                         class t_TAIL_03,
                                         class t_TAIL_04,
                                         class t_TAIL_05,
                                         class t_TAIL_06,
                                         class t_TAIL_07,
                                         class t_TAIL_08,
                                         class t_TAIL_09,
                                         class t_TAIL_10,
                                         class t_TAIL_11,
                                         class t_TAIL_12,
                                         class t_TAIL_13,
                                         class t_TAIL_14,
                                         class t_TAIL_15,
                                         class t_TAIL_16>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16>& input);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 17
template <class t_HASHALG, class t_HEAD, class t_TAIL_01,
                                         class t_TAIL_02,
                                         class t_TAIL_03,
                                         class t_TAIL_04,
                                         class t_TAIL_05,
                                         class t_TAIL_06,
                                         class t_TAIL_07,
                                         class t_TAIL_08,
                                         class t_TAIL_09,
                                         class t_TAIL_10,
                                         class t_TAIL_11,
                                         class t_TAIL_12,
                                         class t_TAIL_13,
                                         class t_TAIL_14,
                                         class t_TAIL_15,
                                         class t_TAIL_16,
                                         class t_TAIL_17>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17>& input);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 18
template <class t_HASHALG, class t_HEAD, class t_TAIL_01,
                                         class t_TAIL_02,
                                         class t_TAIL_03,
                                         class t_TAIL_04,
                                         class t_TAIL_05,
                                         class t_TAIL_06,
                                         class t_TAIL_07,
                                         class t_TAIL_08,
                                         class t_TAIL_09,
                                         class t_TAIL_10,
                                         class t_TAIL_11,
                                         class t_TAIL_12,
                                         class t_TAIL_13,
                                         class t_TAIL_14,
                                         class t_TAIL_15,
                                         class t_TAIL_16,
                                         class t_TAIL_17,
                                         class t_TAIL_18>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17,
                                                          t_TAIL_18>& input);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 18
 
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 0
template <class t_TYPE, class t_HEAD>
bool holds_alternative(
                  const variant<t_HEAD>& obj) BSLS_KEYWORD_NOEXCEPT;
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 1
template <class t_TYPE, class t_HEAD, class t_TAIL_01>
bool holds_alternative(
                  const variant<t_HEAD, t_TAIL_01>& obj) BSLS_KEYWORD_NOEXCEPT;
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 2
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02>
bool holds_alternative(
                  const variant<t_HEAD, t_TAIL_01,
                                        t_TAIL_02>& obj) BSLS_KEYWORD_NOEXCEPT;
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 3
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03>
bool holds_alternative(
                  const variant<t_HEAD, t_TAIL_01,
                                        t_TAIL_02,
                                        t_TAIL_03>& obj) BSLS_KEYWORD_NOEXCEPT;
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 4
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04>
bool holds_alternative(
                  const variant<t_HEAD, t_TAIL_01,
                                        t_TAIL_02,
                                        t_TAIL_03,
                                        t_TAIL_04>& obj) BSLS_KEYWORD_NOEXCEPT;
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 5
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05>
bool holds_alternative(
                  const variant<t_HEAD, t_TAIL_01,
                                        t_TAIL_02,
                                        t_TAIL_03,
                                        t_TAIL_04,
                                        t_TAIL_05>& obj) BSLS_KEYWORD_NOEXCEPT;
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 6
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06>
bool holds_alternative(
                  const variant<t_HEAD, t_TAIL_01,
                                        t_TAIL_02,
                                        t_TAIL_03,
                                        t_TAIL_04,
                                        t_TAIL_05,
                                        t_TAIL_06>& obj) BSLS_KEYWORD_NOEXCEPT;
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 7
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07>
bool holds_alternative(
                  const variant<t_HEAD, t_TAIL_01,
                                        t_TAIL_02,
                                        t_TAIL_03,
                                        t_TAIL_04,
                                        t_TAIL_05,
                                        t_TAIL_06,
                                        t_TAIL_07>& obj) BSLS_KEYWORD_NOEXCEPT;
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 8
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08>
bool holds_alternative(
                  const variant<t_HEAD, t_TAIL_01,
                                        t_TAIL_02,
                                        t_TAIL_03,
                                        t_TAIL_04,
                                        t_TAIL_05,
                                        t_TAIL_06,
                                        t_TAIL_07,
                                        t_TAIL_08>& obj) BSLS_KEYWORD_NOEXCEPT;
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 9
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09>
bool holds_alternative(
                  const variant<t_HEAD, t_TAIL_01,
                                        t_TAIL_02,
                                        t_TAIL_03,
                                        t_TAIL_04,
                                        t_TAIL_05,
                                        t_TAIL_06,
                                        t_TAIL_07,
                                        t_TAIL_08,
                                        t_TAIL_09>& obj) BSLS_KEYWORD_NOEXCEPT;
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 10
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10>
bool holds_alternative(
                  const variant<t_HEAD, t_TAIL_01,
                                        t_TAIL_02,
                                        t_TAIL_03,
                                        t_TAIL_04,
                                        t_TAIL_05,
                                        t_TAIL_06,
                                        t_TAIL_07,
                                        t_TAIL_08,
                                        t_TAIL_09,
                                        t_TAIL_10>& obj) BSLS_KEYWORD_NOEXCEPT;
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 11
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11>
bool holds_alternative(
                  const variant<t_HEAD, t_TAIL_01,
                                        t_TAIL_02,
                                        t_TAIL_03,
                                        t_TAIL_04,
                                        t_TAIL_05,
                                        t_TAIL_06,
                                        t_TAIL_07,
                                        t_TAIL_08,
                                        t_TAIL_09,
                                        t_TAIL_10,
                                        t_TAIL_11>& obj) BSLS_KEYWORD_NOEXCEPT;
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 12
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12>
bool holds_alternative(
                  const variant<t_HEAD, t_TAIL_01,
                                        t_TAIL_02,
                                        t_TAIL_03,
                                        t_TAIL_04,
                                        t_TAIL_05,
                                        t_TAIL_06,
                                        t_TAIL_07,
                                        t_TAIL_08,
                                        t_TAIL_09,
                                        t_TAIL_10,
                                        t_TAIL_11,
                                        t_TAIL_12>& obj) BSLS_KEYWORD_NOEXCEPT;
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 13
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13>
bool holds_alternative(
                  const variant<t_HEAD, t_TAIL_01,
                                        t_TAIL_02,
                                        t_TAIL_03,
                                        t_TAIL_04,
                                        t_TAIL_05,
                                        t_TAIL_06,
                                        t_TAIL_07,
                                        t_TAIL_08,
                                        t_TAIL_09,
                                        t_TAIL_10,
                                        t_TAIL_11,
                                        t_TAIL_12,
                                        t_TAIL_13>& obj) BSLS_KEYWORD_NOEXCEPT;
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 14
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14>
bool holds_alternative(
                  const variant<t_HEAD, t_TAIL_01,
                                        t_TAIL_02,
                                        t_TAIL_03,
                                        t_TAIL_04,
                                        t_TAIL_05,
                                        t_TAIL_06,
                                        t_TAIL_07,
                                        t_TAIL_08,
                                        t_TAIL_09,
                                        t_TAIL_10,
                                        t_TAIL_11,
                                        t_TAIL_12,
                                        t_TAIL_13,
                                        t_TAIL_14>& obj) BSLS_KEYWORD_NOEXCEPT;
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 15
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14,
                                      class t_TAIL_15>
bool holds_alternative(
                  const variant<t_HEAD, t_TAIL_01,
                                        t_TAIL_02,
                                        t_TAIL_03,
                                        t_TAIL_04,
                                        t_TAIL_05,
                                        t_TAIL_06,
                                        t_TAIL_07,
                                        t_TAIL_08,
                                        t_TAIL_09,
                                        t_TAIL_10,
                                        t_TAIL_11,
                                        t_TAIL_12,
                                        t_TAIL_13,
                                        t_TAIL_14,
                                        t_TAIL_15>& obj) BSLS_KEYWORD_NOEXCEPT;
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 16
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14,
                                      class t_TAIL_15,
                                      class t_TAIL_16>
bool holds_alternative(
                  const variant<t_HEAD, t_TAIL_01,
                                        t_TAIL_02,
                                        t_TAIL_03,
                                        t_TAIL_04,
                                        t_TAIL_05,
                                        t_TAIL_06,
                                        t_TAIL_07,
                                        t_TAIL_08,
                                        t_TAIL_09,
                                        t_TAIL_10,
                                        t_TAIL_11,
                                        t_TAIL_12,
                                        t_TAIL_13,
                                        t_TAIL_14,
                                        t_TAIL_15,
                                        t_TAIL_16>& obj) BSLS_KEYWORD_NOEXCEPT;
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 17
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14,
                                      class t_TAIL_15,
                                      class t_TAIL_16,
                                      class t_TAIL_17>
bool holds_alternative(
                  const variant<t_HEAD, t_TAIL_01,
                                        t_TAIL_02,
                                        t_TAIL_03,
                                        t_TAIL_04,
                                        t_TAIL_05,
                                        t_TAIL_06,
                                        t_TAIL_07,
                                        t_TAIL_08,
                                        t_TAIL_09,
                                        t_TAIL_10,
                                        t_TAIL_11,
                                        t_TAIL_12,
                                        t_TAIL_13,
                                        t_TAIL_14,
                                        t_TAIL_15,
                                        t_TAIL_16,
                                        t_TAIL_17>& obj) BSLS_KEYWORD_NOEXCEPT;
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 18
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14,
                                      class t_TAIL_15,
                                      class t_TAIL_16,
                                      class t_TAIL_17,
                                      class t_TAIL_18>
bool holds_alternative(
                  const variant<t_HEAD, t_TAIL_01,
                                        t_TAIL_02,
                                        t_TAIL_03,
                                        t_TAIL_04,
                                        t_TAIL_05,
                                        t_TAIL_06,
                                        t_TAIL_07,
                                        t_TAIL_08,
                                        t_TAIL_09,
                                        t_TAIL_10,
                                        t_TAIL_11,
                                        t_TAIL_12,
                                        t_TAIL_13,
                                        t_TAIL_14,
                                        t_TAIL_15,
                                        t_TAIL_16,
                                        t_TAIL_17,
                                        t_TAIL_18>& obj) BSLS_KEYWORD_NOEXCEPT;
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_C >= 18
 
#else
// The generated code below is a workaround for the absence of perfect
// forwarding in some compilers.
 
template <size_t t_INDEX,
          class t_HEAD = BSLSTL_VARIANT_NOT_A_TYPE,
          class... t_TAIL>
struct Variant_VariantAlternativeImpl
: Variant_VariantAlternativeImpl<t_INDEX - 1, t_TAIL...> {
};
 
template <size_t t_INDEX>
struct Variant_VariantAlternativeImpl<t_INDEX, BSLSTL_VARIANT_NOT_A_TYPE> {
};
 
template <>
struct Variant_VariantAlternativeImpl<0, BSLSTL_VARIANT_NOT_A_TYPE> {
};
 
template <class t_HEAD, class... t_TAIL>
struct Variant_VariantAlternativeImpl<0, t_HEAD, t_TAIL...> {
    typedef t_HEAD type;
};
 
template <size_t t_INDEX, class t_HEAD, class... t_TAIL>
struct variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL...> >
: Variant_VariantAlternativeImpl<t_INDEX, t_HEAD, t_TAIL...> {
    BSLMF_ASSERT((t_INDEX <
                  bsl::variant_size<variant<t_HEAD, t_TAIL...> >::value));
};
 
#ifdef BSLS_COMPILERFEATURES_SUPPORT_ALIAS_TEMPLATES
template <size_t t_INDEX, class t_TYPE>
using variant_alternative_t =
    typename variant_alternative<t_INDEX, t_TYPE>::type;
#endif
 
 
template <class t_HEAD, class... t_TAIL>
void swap(bsl::variant<t_HEAD, t_TAIL...>& lhs,
          bsl::variant<t_HEAD, t_TAIL...>& rhs);
 
 
template <class t_HASHALG, class t_HEAD, class... t_TAIL>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD, t_TAIL...>& input);
 
 
template <class t_TYPE, class t_HEAD, class... t_TAIL>
bool holds_alternative(
                  const variant<t_HEAD, t_TAIL...>& obj) BSLS_KEYWORD_NOEXCEPT;
// }}} END GENERATED CODE
#endif
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
/// Return a reference to the alternative object at index (template
/// parameter) `t_INDEX` in the specified `obj`.  If `t_INDEX` is not the
/// index of the currently active alternative, throw an exception of type
/// `bad_variant_access`.  `t_INDEX` shall be a valid index for the variant
/// type of `obj`.
template <size_t t_INDEX, class t_HEAD, class... t_TAIL>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL...> >::type& get(
                                              variant<t_HEAD, t_TAIL...>& obj);
template <size_t t_INDEX, class t_HEAD, class... t_TAIL>
const typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL...> >::type&
get(const variant<t_HEAD, t_TAIL...>& obj);
template <size_t t_INDEX, class t_HEAD, class... t_TAIL>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL...> >::type&& get(
                                             variant<t_HEAD, t_TAIL...>&& obj);
template <size_t t_INDEX, class t_HEAD, class... t_TAIL>
const typename variant_alternative<t_INDEX,
                                   variant<t_HEAD, t_TAIL...> >::type&&
get(const variant<t_HEAD, t_TAIL...>&& obj);
 
/// Return a reference to the alternative object with type (template
/// parameter) `t_TYPE` in the specified `obj`.  If `t_TYPE` is not the type
/// of the currently active alternative, throw an exception of type
/// `bad_variant_access`.  `t_TYPE` shall appear exactly once in the
/// variant's list of alternatives.
template <class t_TYPE, class t_HEAD, class... t_TAIL>
t_TYPE& get(variant<t_HEAD, t_TAIL...>& obj);
template <class t_TYPE, class t_HEAD, class... t_TAIL>
const t_TYPE& get(const variant<t_HEAD, t_TAIL...>& obj);
template <class t_TYPE, class t_HEAD, class... t_TAIL>
t_TYPE&& get(variant<t_HEAD, t_TAIL...>&& obj);
template <class t_TYPE, class t_HEAD, class... t_TAIL>
const t_TYPE&& get(const variant<t_HEAD, t_TAIL...>&& obj);
 
template <size_t t_INDEX, class t_HEAD, class... t_TAIL>
typename add_pointer<
    typename variant_alternative<t_INDEX,
                                 variant<t_HEAD, t_TAIL...> >::type>::type
get_if(variant<t_HEAD, t_TAIL...> *obj) BSLS_KEYWORD_NOEXCEPT;
 
/// Return a pointer to the alternative object with index (template
/// parameter) `t_INDEX` in the specified `obj`, or a null pointer if `obj`
/// itself is a null pointer or if `t_INDEX` is not the index of the
/// currently active alternative.  `t_INDEX` shall be a valid alternative
/// index.
template <size_t t_INDEX, class t_HEAD, class... t_TAIL>
typename add_pointer<const typename variant_alternative<
    t_INDEX,
    variant<t_HEAD, t_TAIL...> >::type>::type
get_if(const variant<t_HEAD, t_TAIL...> *obj) BSLS_KEYWORD_NOEXCEPT;
 
template <class t_TYPE, class t_HEAD, class... t_TAIL>
typename add_pointer<t_TYPE>::type get_if(
                        variant<t_HEAD, t_TAIL...> *obj) BSLS_KEYWORD_NOEXCEPT;
 
/// Return a pointer to the alternative object with type (template
/// parameter) `t_TYPE` in the specified `obj`, or a null pointer if `obj`
/// itself is a null pointer or if `t_TYPE` is not the type of the currently
/// active alternative.  `t_TYPE` shall appear exactly once in the variant's
/// list of alternatives.
template <class t_TYPE, class t_HEAD, class... t_TAIL>
typename add_pointer<const t_TYPE>::type get_if(
                  const variant<t_HEAD, t_TAIL...> *obj) BSLS_KEYWORD_NOEXCEPT;
#else  // BSL_VARIANT_FULL_IMPLEMENTATION
 
// See 'bslstl_variant.cpp' for implementation notes regarding 'bsl::get'.
template <bool t_VALID, size_t t_INDEX, class t_ARG, class t_VARIANT>
struct Variant_GetIndexReturnTypeImpl {
    // This component-private metafunction computes the return types for
    // 'bsl::get<t_INDEX>' and 'bsl::get_if<t_INDEX>' with an argument of type
    // 't_ARG' or 't_ARG*', respectively, where 't_VARIANT' is 't_ARG' with
    // cvref-qualifiers stripped, and shall be a specialization of
    // 'bsl::variant'.  't_VALID' shall be 'true' if and only if 't_INDEX' is a
    // valid index for 't_VARIANT'.  If 't_VALID' is 'false', no member
    // typedefs are provided.
};
 
template <size_t t_INDEX, class t_VARIANT>
struct Variant_GetIndexReturnTypeImpl<true, t_INDEX, t_VARIANT, t_VARIANT> {
    typedef typename bsl::variant_alternative<t_INDEX, t_VARIANT>::type& type;
 
    typedef
        typename bsl::variant_alternative<t_INDEX, t_VARIANT>::type *pointer;
};
 
template <size_t t_INDEX, class t_VARIANT>
struct Variant_GetIndexReturnTypeImpl<true,
                                      t_INDEX,
                                      const t_VARIANT,
                                      t_VARIANT> {
    typedef typename bsl::variant_alternative<t_INDEX, const t_VARIANT>::type&
        type;
 
    typedef typename bsl::variant_alternative<t_INDEX, const t_VARIANT>::type
        *pointer;
};
 
template <size_t t_INDEX, class t_VARIANT>
struct Variant_GetIndexReturnTypeImpl<
    true,
    t_INDEX,
    BloombergLP::bslmf::MovableRef<t_VARIANT>,
    t_VARIANT> {
    typedef BloombergLP::bslmf::MovableRef<
        typename bsl::variant_alternative<t_INDEX, t_VARIANT>::type>
        type;
};
 
template <size_t t_INDEX,
          class  t_ARG,
          class  t_VARIANT = typename BloombergLP::bslmf::MovableRefUtil::
              Decay<t_ARG>::type>
struct Variant_GetIndexReturnType;
    // This component-private metafunction computes the return types for
    // 'bsl::get<t_INDEX>' and 'bsl::get_if<t_INDEX>' with an argument of type
    // 't_ARG' or 't_ARG*' respectively.  If 't_ARG' is not a (possibly
    // cvref-qualified) 'bsl::variant', no definition is provided.  If
    // 't_INDEX' is not a valid index for 't_ARG', the member typedefs 'type'
    // and 'pointer' are not provided.
 
#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
// {{{ BEGIN GENERATED CODE
// Command line: sim_cpp11_features.pl bslstl_variant.h
#ifndef BSLSTL_VARIANT_VARIADIC_LIMIT
#define BSLSTL_VARIANT_VARIADIC_LIMIT 18
#endif
#ifndef BSLSTL_VARIANT_VARIADIC_LIMIT_D
#define BSLSTL_VARIANT_VARIADIC_LIMIT_D BSLSTL_VARIANT_VARIADIC_LIMIT
#endif
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 0
template <size_t t_INDEX, class t_ARG, class t_HEAD>
struct Variant_GetIndexReturnType<t_INDEX,
                                  t_ARG,
                                  bsl::variant<t_HEAD> >
: Variant_GetIndexReturnTypeImpl<(t_INDEX <=  0u),
                                 t_INDEX,
                                 t_ARG,
                                 bsl::variant<t_HEAD> > {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 1
template <size_t t_INDEX, class t_ARG, class t_HEAD, class t_TAIL_01>
struct Variant_GetIndexReturnType<t_INDEX,
                                  t_ARG,
                                  bsl::variant<t_HEAD, t_TAIL_01> >
: Variant_GetIndexReturnTypeImpl<(t_INDEX <=  1u),
                                 t_INDEX,
                                 t_ARG,
                                 bsl::variant<t_HEAD, t_TAIL_01> > {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 2
template <size_t t_INDEX, class t_ARG, class t_HEAD, class t_TAIL_01,
                                                     class t_TAIL_02>
struct Variant_GetIndexReturnType<t_INDEX,
                                  t_ARG,
                                  bsl::variant<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02> >
: Variant_GetIndexReturnTypeImpl<(t_INDEX <=  2u),
                                 t_INDEX,
                                 t_ARG,
                                 bsl::variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02> > {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 3
template <size_t t_INDEX, class t_ARG, class t_HEAD, class t_TAIL_01,
                                                     class t_TAIL_02,
                                                     class t_TAIL_03>
struct Variant_GetIndexReturnType<t_INDEX,
                                  t_ARG,
                                  bsl::variant<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03> >
: Variant_GetIndexReturnTypeImpl<(t_INDEX <=  3u),
                                 t_INDEX,
                                 t_ARG,
                                 bsl::variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03> > {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 4
template <size_t t_INDEX, class t_ARG, class t_HEAD, class t_TAIL_01,
                                                     class t_TAIL_02,
                                                     class t_TAIL_03,
                                                     class t_TAIL_04>
struct Variant_GetIndexReturnType<t_INDEX,
                                  t_ARG,
                                  bsl::variant<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04> >
: Variant_GetIndexReturnTypeImpl<(t_INDEX <=  4u),
                                 t_INDEX,
                                 t_ARG,
                                 bsl::variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04> > {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 5
template <size_t t_INDEX, class t_ARG, class t_HEAD, class t_TAIL_01,
                                                     class t_TAIL_02,
                                                     class t_TAIL_03,
                                                     class t_TAIL_04,
                                                     class t_TAIL_05>
struct Variant_GetIndexReturnType<t_INDEX,
                                  t_ARG,
                                  bsl::variant<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05> >
: Variant_GetIndexReturnTypeImpl<(t_INDEX <=  5u),
                                 t_INDEX,
                                 t_ARG,
                                 bsl::variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05> > {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 6
template <size_t t_INDEX, class t_ARG, class t_HEAD, class t_TAIL_01,
                                                     class t_TAIL_02,
                                                     class t_TAIL_03,
                                                     class t_TAIL_04,
                                                     class t_TAIL_05,
                                                     class t_TAIL_06>
struct Variant_GetIndexReturnType<t_INDEX,
                                  t_ARG,
                                  bsl::variant<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06> >
: Variant_GetIndexReturnTypeImpl<(t_INDEX <=  6u),
                                 t_INDEX,
                                 t_ARG,
                                 bsl::variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06> > {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 7
template <size_t t_INDEX, class t_ARG, class t_HEAD, class t_TAIL_01,
                                                     class t_TAIL_02,
                                                     class t_TAIL_03,
                                                     class t_TAIL_04,
                                                     class t_TAIL_05,
                                                     class t_TAIL_06,
                                                     class t_TAIL_07>
struct Variant_GetIndexReturnType<t_INDEX,
                                  t_ARG,
                                  bsl::variant<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07> >
: Variant_GetIndexReturnTypeImpl<(t_INDEX <=  7u),
                                 t_INDEX,
                                 t_ARG,
                                 bsl::variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07> > {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 8
template <size_t t_INDEX, class t_ARG, class t_HEAD, class t_TAIL_01,
                                                     class t_TAIL_02,
                                                     class t_TAIL_03,
                                                     class t_TAIL_04,
                                                     class t_TAIL_05,
                                                     class t_TAIL_06,
                                                     class t_TAIL_07,
                                                     class t_TAIL_08>
struct Variant_GetIndexReturnType<t_INDEX,
                                  t_ARG,
                                  bsl::variant<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08> >
: Variant_GetIndexReturnTypeImpl<(t_INDEX <=  8u),
                                 t_INDEX,
                                 t_ARG,
                                 bsl::variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08> > {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 9
template <size_t t_INDEX, class t_ARG, class t_HEAD, class t_TAIL_01,
                                                     class t_TAIL_02,
                                                     class t_TAIL_03,
                                                     class t_TAIL_04,
                                                     class t_TAIL_05,
                                                     class t_TAIL_06,
                                                     class t_TAIL_07,
                                                     class t_TAIL_08,
                                                     class t_TAIL_09>
struct Variant_GetIndexReturnType<t_INDEX,
                                  t_ARG,
                                  bsl::variant<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09> >
: Variant_GetIndexReturnTypeImpl<(t_INDEX <=  9u),
                                 t_INDEX,
                                 t_ARG,
                                 bsl::variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09> > {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 10
template <size_t t_INDEX, class t_ARG, class t_HEAD, class t_TAIL_01,
                                                     class t_TAIL_02,
                                                     class t_TAIL_03,
                                                     class t_TAIL_04,
                                                     class t_TAIL_05,
                                                     class t_TAIL_06,
                                                     class t_TAIL_07,
                                                     class t_TAIL_08,
                                                     class t_TAIL_09,
                                                     class t_TAIL_10>
struct Variant_GetIndexReturnType<t_INDEX,
                                  t_ARG,
                                  bsl::variant<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10> >
: Variant_GetIndexReturnTypeImpl<(t_INDEX <= 10u),
                                 t_INDEX,
                                 t_ARG,
                                 bsl::variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10> > {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 11
template <size_t t_INDEX, class t_ARG, class t_HEAD, class t_TAIL_01,
                                                     class t_TAIL_02,
                                                     class t_TAIL_03,
                                                     class t_TAIL_04,
                                                     class t_TAIL_05,
                                                     class t_TAIL_06,
                                                     class t_TAIL_07,
                                                     class t_TAIL_08,
                                                     class t_TAIL_09,
                                                     class t_TAIL_10,
                                                     class t_TAIL_11>
struct Variant_GetIndexReturnType<t_INDEX,
                                  t_ARG,
                                  bsl::variant<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11> >
: Variant_GetIndexReturnTypeImpl<(t_INDEX <= 11u),
                                 t_INDEX,
                                 t_ARG,
                                 bsl::variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11> > {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 12
template <size_t t_INDEX, class t_ARG, class t_HEAD, class t_TAIL_01,
                                                     class t_TAIL_02,
                                                     class t_TAIL_03,
                                                     class t_TAIL_04,
                                                     class t_TAIL_05,
                                                     class t_TAIL_06,
                                                     class t_TAIL_07,
                                                     class t_TAIL_08,
                                                     class t_TAIL_09,
                                                     class t_TAIL_10,
                                                     class t_TAIL_11,
                                                     class t_TAIL_12>
struct Variant_GetIndexReturnType<t_INDEX,
                                  t_ARG,
                                  bsl::variant<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11,
                                                       t_TAIL_12> >
: Variant_GetIndexReturnTypeImpl<(t_INDEX <= 12u),
                                 t_INDEX,
                                 t_ARG,
                                 bsl::variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12> > {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 13
template <size_t t_INDEX, class t_ARG, class t_HEAD, class t_TAIL_01,
                                                     class t_TAIL_02,
                                                     class t_TAIL_03,
                                                     class t_TAIL_04,
                                                     class t_TAIL_05,
                                                     class t_TAIL_06,
                                                     class t_TAIL_07,
                                                     class t_TAIL_08,
                                                     class t_TAIL_09,
                                                     class t_TAIL_10,
                                                     class t_TAIL_11,
                                                     class t_TAIL_12,
                                                     class t_TAIL_13>
struct Variant_GetIndexReturnType<t_INDEX,
                                  t_ARG,
                                  bsl::variant<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11,
                                                       t_TAIL_12,
                                                       t_TAIL_13> >
: Variant_GetIndexReturnTypeImpl<(t_INDEX <= 13u),
                                 t_INDEX,
                                 t_ARG,
                                 bsl::variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13> > {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 14
template <size_t t_INDEX, class t_ARG, class t_HEAD, class t_TAIL_01,
                                                     class t_TAIL_02,
                                                     class t_TAIL_03,
                                                     class t_TAIL_04,
                                                     class t_TAIL_05,
                                                     class t_TAIL_06,
                                                     class t_TAIL_07,
                                                     class t_TAIL_08,
                                                     class t_TAIL_09,
                                                     class t_TAIL_10,
                                                     class t_TAIL_11,
                                                     class t_TAIL_12,
                                                     class t_TAIL_13,
                                                     class t_TAIL_14>
struct Variant_GetIndexReturnType<t_INDEX,
                                  t_ARG,
                                  bsl::variant<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11,
                                                       t_TAIL_12,
                                                       t_TAIL_13,
                                                       t_TAIL_14> >
: Variant_GetIndexReturnTypeImpl<(t_INDEX <= 14u),
                                 t_INDEX,
                                 t_ARG,
                                 bsl::variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14> > {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 15
template <size_t t_INDEX, class t_ARG, class t_HEAD, class t_TAIL_01,
                                                     class t_TAIL_02,
                                                     class t_TAIL_03,
                                                     class t_TAIL_04,
                                                     class t_TAIL_05,
                                                     class t_TAIL_06,
                                                     class t_TAIL_07,
                                                     class t_TAIL_08,
                                                     class t_TAIL_09,
                                                     class t_TAIL_10,
                                                     class t_TAIL_11,
                                                     class t_TAIL_12,
                                                     class t_TAIL_13,
                                                     class t_TAIL_14,
                                                     class t_TAIL_15>
struct Variant_GetIndexReturnType<t_INDEX,
                                  t_ARG,
                                  bsl::variant<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11,
                                                       t_TAIL_12,
                                                       t_TAIL_13,
                                                       t_TAIL_14,
                                                       t_TAIL_15> >
: Variant_GetIndexReturnTypeImpl<(t_INDEX <= 15u),
                                 t_INDEX,
                                 t_ARG,
                                 bsl::variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15> > {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 16
template <size_t t_INDEX, class t_ARG, class t_HEAD, class t_TAIL_01,
                                                     class t_TAIL_02,
                                                     class t_TAIL_03,
                                                     class t_TAIL_04,
                                                     class t_TAIL_05,
                                                     class t_TAIL_06,
                                                     class t_TAIL_07,
                                                     class t_TAIL_08,
                                                     class t_TAIL_09,
                                                     class t_TAIL_10,
                                                     class t_TAIL_11,
                                                     class t_TAIL_12,
                                                     class t_TAIL_13,
                                                     class t_TAIL_14,
                                                     class t_TAIL_15,
                                                     class t_TAIL_16>
struct Variant_GetIndexReturnType<t_INDEX,
                                  t_ARG,
                                  bsl::variant<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11,
                                                       t_TAIL_12,
                                                       t_TAIL_13,
                                                       t_TAIL_14,
                                                       t_TAIL_15,
                                                       t_TAIL_16> >
: Variant_GetIndexReturnTypeImpl<(t_INDEX <= 16u),
                                 t_INDEX,
                                 t_ARG,
                                 bsl::variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16> > {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 17
template <size_t t_INDEX, class t_ARG, class t_HEAD, class t_TAIL_01,
                                                     class t_TAIL_02,
                                                     class t_TAIL_03,
                                                     class t_TAIL_04,
                                                     class t_TAIL_05,
                                                     class t_TAIL_06,
                                                     class t_TAIL_07,
                                                     class t_TAIL_08,
                                                     class t_TAIL_09,
                                                     class t_TAIL_10,
                                                     class t_TAIL_11,
                                                     class t_TAIL_12,
                                                     class t_TAIL_13,
                                                     class t_TAIL_14,
                                                     class t_TAIL_15,
                                                     class t_TAIL_16,
                                                     class t_TAIL_17>
struct Variant_GetIndexReturnType<t_INDEX,
                                  t_ARG,
                                  bsl::variant<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11,
                                                       t_TAIL_12,
                                                       t_TAIL_13,
                                                       t_TAIL_14,
                                                       t_TAIL_15,
                                                       t_TAIL_16,
                                                       t_TAIL_17> >
: Variant_GetIndexReturnTypeImpl<(t_INDEX <= 17u),
                                 t_INDEX,
                                 t_ARG,
                                 bsl::variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16,
                                                      t_TAIL_17> > {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 18
template <size_t t_INDEX, class t_ARG, class t_HEAD, class t_TAIL_01,
                                                     class t_TAIL_02,
                                                     class t_TAIL_03,
                                                     class t_TAIL_04,
                                                     class t_TAIL_05,
                                                     class t_TAIL_06,
                                                     class t_TAIL_07,
                                                     class t_TAIL_08,
                                                     class t_TAIL_09,
                                                     class t_TAIL_10,
                                                     class t_TAIL_11,
                                                     class t_TAIL_12,
                                                     class t_TAIL_13,
                                                     class t_TAIL_14,
                                                     class t_TAIL_15,
                                                     class t_TAIL_16,
                                                     class t_TAIL_17,
                                                     class t_TAIL_18>
struct Variant_GetIndexReturnType<t_INDEX,
                                  t_ARG,
                                  bsl::variant<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11,
                                                       t_TAIL_12,
                                                       t_TAIL_13,
                                                       t_TAIL_14,
                                                       t_TAIL_15,
                                                       t_TAIL_16,
                                                       t_TAIL_17,
                                                       t_TAIL_18> >
: Variant_GetIndexReturnTypeImpl<(t_INDEX <= 18u),
                                 t_INDEX,
                                 t_ARG,
                                 bsl::variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16,
                                                      t_TAIL_17,
                                                      t_TAIL_18> > {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 18
 
 
template <class t_TYPE,
          class t_HEAD
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 0
        , class t_TAIL_0 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 1
        , class t_TAIL_1 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 2
        , class t_TAIL_2 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 3
        , class t_TAIL_3 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 4
        , class t_TAIL_4 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 5
        , class t_TAIL_5 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 6
        , class t_TAIL_6 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 7
        , class t_TAIL_7 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 8
        , class t_TAIL_8 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 9
        , class t_TAIL_9 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 10
        , class t_TAIL_10 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 11
        , class t_TAIL_11 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 12
        , class t_TAIL_12 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 13
        , class t_TAIL_13 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 14
        , class t_TAIL_14 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 15
        , class t_TAIL_15 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 16
        , class t_TAIL_16 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 17
        , class t_TAIL_17 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 17
        , class = BSLS_COMPILERFEATURES_NILT>
struct Variant_GetTypeReturnType;
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 0
template <class t_TYPE, class t_HEAD>
struct Variant_GetTypeReturnType<t_TYPE, bsl::variant<t_HEAD> > {
    typedef t_TYPE                             type;
    typedef typename add_pointer<t_TYPE>::type pointer;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 1
template <class t_TYPE, class t_HEAD, class t_TAIL_01>
struct Variant_GetTypeReturnType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01> > {
    typedef t_TYPE                             type;
    typedef typename add_pointer<t_TYPE>::type pointer;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 2
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02>
struct Variant_GetTypeReturnType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                              t_TAIL_02> > {
    typedef t_TYPE                             type;
    typedef typename add_pointer<t_TYPE>::type pointer;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 3
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03>
struct Variant_GetTypeReturnType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                              t_TAIL_02,
                                                              t_TAIL_03> > {
    typedef t_TYPE                             type;
    typedef typename add_pointer<t_TYPE>::type pointer;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 4
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04>
struct Variant_GetTypeReturnType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                              t_TAIL_02,
                                                              t_TAIL_03,
                                                              t_TAIL_04> > {
    typedef t_TYPE                             type;
    typedef typename add_pointer<t_TYPE>::type pointer;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 5
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05>
struct Variant_GetTypeReturnType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                              t_TAIL_02,
                                                              t_TAIL_03,
                                                              t_TAIL_04,
                                                              t_TAIL_05> > {
    typedef t_TYPE                             type;
    typedef typename add_pointer<t_TYPE>::type pointer;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 6
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06>
struct Variant_GetTypeReturnType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                              t_TAIL_02,
                                                              t_TAIL_03,
                                                              t_TAIL_04,
                                                              t_TAIL_05,
                                                              t_TAIL_06> > {
    typedef t_TYPE                             type;
    typedef typename add_pointer<t_TYPE>::type pointer;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 7
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07>
struct Variant_GetTypeReturnType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                              t_TAIL_02,
                                                              t_TAIL_03,
                                                              t_TAIL_04,
                                                              t_TAIL_05,
                                                              t_TAIL_06,
                                                              t_TAIL_07> > {
    typedef t_TYPE                             type;
    typedef typename add_pointer<t_TYPE>::type pointer;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 8
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08>
struct Variant_GetTypeReturnType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                              t_TAIL_02,
                                                              t_TAIL_03,
                                                              t_TAIL_04,
                                                              t_TAIL_05,
                                                              t_TAIL_06,
                                                              t_TAIL_07,
                                                              t_TAIL_08> > {
    typedef t_TYPE                             type;
    typedef typename add_pointer<t_TYPE>::type pointer;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 9
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09>
struct Variant_GetTypeReturnType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                              t_TAIL_02,
                                                              t_TAIL_03,
                                                              t_TAIL_04,
                                                              t_TAIL_05,
                                                              t_TAIL_06,
                                                              t_TAIL_07,
                                                              t_TAIL_08,
                                                              t_TAIL_09> > {
    typedef t_TYPE                             type;
    typedef typename add_pointer<t_TYPE>::type pointer;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 10
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10>
struct Variant_GetTypeReturnType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                              t_TAIL_02,
                                                              t_TAIL_03,
                                                              t_TAIL_04,
                                                              t_TAIL_05,
                                                              t_TAIL_06,
                                                              t_TAIL_07,
                                                              t_TAIL_08,
                                                              t_TAIL_09,
                                                              t_TAIL_10> > {
    typedef t_TYPE                             type;
    typedef typename add_pointer<t_TYPE>::type pointer;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 11
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11>
struct Variant_GetTypeReturnType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                              t_TAIL_02,
                                                              t_TAIL_03,
                                                              t_TAIL_04,
                                                              t_TAIL_05,
                                                              t_TAIL_06,
                                                              t_TAIL_07,
                                                              t_TAIL_08,
                                                              t_TAIL_09,
                                                              t_TAIL_10,
                                                              t_TAIL_11> > {
    typedef t_TYPE                             type;
    typedef typename add_pointer<t_TYPE>::type pointer;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 12
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12>
struct Variant_GetTypeReturnType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                              t_TAIL_02,
                                                              t_TAIL_03,
                                                              t_TAIL_04,
                                                              t_TAIL_05,
                                                              t_TAIL_06,
                                                              t_TAIL_07,
                                                              t_TAIL_08,
                                                              t_TAIL_09,
                                                              t_TAIL_10,
                                                              t_TAIL_11,
                                                              t_TAIL_12> > {
    typedef t_TYPE                             type;
    typedef typename add_pointer<t_TYPE>::type pointer;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 13
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13>
struct Variant_GetTypeReturnType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                              t_TAIL_02,
                                                              t_TAIL_03,
                                                              t_TAIL_04,
                                                              t_TAIL_05,
                                                              t_TAIL_06,
                                                              t_TAIL_07,
                                                              t_TAIL_08,
                                                              t_TAIL_09,
                                                              t_TAIL_10,
                                                              t_TAIL_11,
                                                              t_TAIL_12,
                                                              t_TAIL_13> > {
    typedef t_TYPE                             type;
    typedef typename add_pointer<t_TYPE>::type pointer;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 14
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14>
struct Variant_GetTypeReturnType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                              t_TAIL_02,
                                                              t_TAIL_03,
                                                              t_TAIL_04,
                                                              t_TAIL_05,
                                                              t_TAIL_06,
                                                              t_TAIL_07,
                                                              t_TAIL_08,
                                                              t_TAIL_09,
                                                              t_TAIL_10,
                                                              t_TAIL_11,
                                                              t_TAIL_12,
                                                              t_TAIL_13,
                                                              t_TAIL_14> > {
    typedef t_TYPE                             type;
    typedef typename add_pointer<t_TYPE>::type pointer;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 15
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14,
                                      class t_TAIL_15>
struct Variant_GetTypeReturnType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                              t_TAIL_02,
                                                              t_TAIL_03,
                                                              t_TAIL_04,
                                                              t_TAIL_05,
                                                              t_TAIL_06,
                                                              t_TAIL_07,
                                                              t_TAIL_08,
                                                              t_TAIL_09,
                                                              t_TAIL_10,
                                                              t_TAIL_11,
                                                              t_TAIL_12,
                                                              t_TAIL_13,
                                                              t_TAIL_14,
                                                              t_TAIL_15> > {
    typedef t_TYPE                             type;
    typedef typename add_pointer<t_TYPE>::type pointer;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 16
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14,
                                      class t_TAIL_15,
                                      class t_TAIL_16>
struct Variant_GetTypeReturnType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                              t_TAIL_02,
                                                              t_TAIL_03,
                                                              t_TAIL_04,
                                                              t_TAIL_05,
                                                              t_TAIL_06,
                                                              t_TAIL_07,
                                                              t_TAIL_08,
                                                              t_TAIL_09,
                                                              t_TAIL_10,
                                                              t_TAIL_11,
                                                              t_TAIL_12,
                                                              t_TAIL_13,
                                                              t_TAIL_14,
                                                              t_TAIL_15,
                                                              t_TAIL_16> > {
    typedef t_TYPE                             type;
    typedef typename add_pointer<t_TYPE>::type pointer;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 17
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14,
                                      class t_TAIL_15,
                                      class t_TAIL_16,
                                      class t_TAIL_17>
struct Variant_GetTypeReturnType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                              t_TAIL_02,
                                                              t_TAIL_03,
                                                              t_TAIL_04,
                                                              t_TAIL_05,
                                                              t_TAIL_06,
                                                              t_TAIL_07,
                                                              t_TAIL_08,
                                                              t_TAIL_09,
                                                              t_TAIL_10,
                                                              t_TAIL_11,
                                                              t_TAIL_12,
                                                              t_TAIL_13,
                                                              t_TAIL_14,
                                                              t_TAIL_15,
                                                              t_TAIL_16,
                                                              t_TAIL_17> > {
    typedef t_TYPE                             type;
    typedef typename add_pointer<t_TYPE>::type pointer;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 18
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14,
                                      class t_TAIL_15,
                                      class t_TAIL_16,
                                      class t_TAIL_17,
                                      class t_TAIL_18>
struct Variant_GetTypeReturnType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                              t_TAIL_02,
                                                              t_TAIL_03,
                                                              t_TAIL_04,
                                                              t_TAIL_05,
                                                              t_TAIL_06,
                                                              t_TAIL_07,
                                                              t_TAIL_08,
                                                              t_TAIL_09,
                                                              t_TAIL_10,
                                                              t_TAIL_11,
                                                              t_TAIL_12,
                                                              t_TAIL_13,
                                                              t_TAIL_14,
                                                              t_TAIL_15,
                                                              t_TAIL_16,
                                                              t_TAIL_17,
                                                              t_TAIL_18> > {
    typedef t_TYPE                             type;
    typedef typename add_pointer<t_TYPE>::type pointer;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_D >= 18
 
#else
// The generated code below is a workaround for the absence of perfect
// forwarding in some compilers.
template <size_t t_INDEX, class t_ARG, class t_HEAD, class... t_TAIL>
struct Variant_GetIndexReturnType<t_INDEX,
                                  t_ARG,
                                  bsl::variant<t_HEAD, t_TAIL...> >
: Variant_GetIndexReturnTypeImpl<(t_INDEX <= sizeof...(t_TAIL)),
                                 t_INDEX,
                                 t_ARG,
                                 bsl::variant<t_HEAD, t_TAIL...> > {
};
 
template <class t_TYPE, class t_HEAD, class... t_TAIL>
struct Variant_GetTypeReturnType;
 
template <class t_TYPE, class t_HEAD, class... t_TAIL>
struct Variant_GetTypeReturnType<t_TYPE, bsl::variant<t_HEAD, t_TAIL...> > {
    typedef t_TYPE                             type;
    typedef typename add_pointer<t_TYPE>::type pointer;
};
// }}} END GENERATED CODE
#endif
 
template <size_t t_INDEX, class t_VARIANT>
typename Variant_GetIndexReturnType<t_INDEX, t_VARIANT>::type
get(t_VARIANT&                                obj);
template <size_t t_INDEX, class t_VARIANT>
typename Variant_GetIndexReturnType<
    t_INDEX,
    BloombergLP::bslmf::MovableRef<t_VARIANT> >::type
get(BloombergLP::bslmf::MovableRef<t_VARIANT> obj);
    // Return a reference to the alternative object at index (template
    // parameter) 't_INDEX' in the specified 'obj'.  If 't_INDEX' is not the
    // index of the currently active alternative, throw an exception of type
    // 'bad_variant_access'.  't_INDEX' shall be a valid index for the variant
    // type of 'obj'.  Note that 't_VARIANT' may be const-qualified.
 
template <class t_TYPE, class t_VARIANT>
typename Variant_GetTypeReturnType<t_TYPE&, t_VARIANT>::type get(
                                t_VARIANT&                                obj);
template <class t_TYPE, class t_VARIANT>
typename Variant_GetTypeReturnType<const t_TYPE&, t_VARIANT>::type get(
                                const t_VARIANT&                          obj);
template <class t_TYPE, class t_VARIANT>
typename Variant_GetTypeReturnType<BloombergLP::bslmf::MovableRef<t_TYPE>,
                                   t_VARIANT>::type get(
                                BloombergLP::bslmf::MovableRef<t_VARIANT> obj);
    // Return a reference to the alternative object with type (template
    // parameter) 't_TYPE' in the specified 'obj'.  If 't_TYPE' is not the type
    // of the currently active alternative, throw an exception of type
    // 'bad_variant_access'.  't_TYPE' shall appear exactly once in the
    // variant's list of alternatives.
 
template <size_t t_INDEX, class t_VARIANT>
typename Variant_GetIndexReturnType<t_INDEX, t_VARIANT>::pointer
get_if(t_VARIANT *obj) BSLS_KEYWORD_NOEXCEPT;
    // Return a pointer to the alternative object with index (template
    // parameter) 't_INDEX' in the specified 'obj', or a null pointer if 'obj'
    // itself is a null pointer or if 't_INDEX' is not the index of the
    // currently active alternative.  't_INDEX' shall be a valid alternative
    // index.  Note that 't_VARIANT' may be const-qualified.
 
template <class t_TYPE, class t_VARIANT>
typename Variant_GetTypeReturnType<t_TYPE, t_VARIANT>::pointer get_if(
                                         t_VARIANT *obj) BSLS_KEYWORD_NOEXCEPT;
template <class t_TYPE, class t_VARIANT>
typename Variant_GetTypeReturnType<const t_TYPE, t_VARIANT>::pointer get_if(
                                   const t_VARIANT *obj) BSLS_KEYWORD_NOEXCEPT;
    // Return a pointer to the alternative object with type (template
    // parameter) 't_TYPE' in the specified 'obj', or a null pointer if 'obj'
    // itself is a null pointer or if 't_TYPE' is not the type of the currently
    // active alternative.  't_TYPE' shall appear exactly once in the variant's
    // list of alternatives.
#endif  // BSL_VARIANT_FULL_IMPLEMENTATION
// FREE OPERATORS
 
// 20.7.6, relational operators
#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
// {{{ BEGIN GENERATED CODE
// Command line: sim_cpp11_features.pl bslstl_variant.h
#ifndef BSLSTL_VARIANT_VARIADIC_LIMIT
#define BSLSTL_VARIANT_VARIADIC_LIMIT 18
#endif
#ifndef BSLSTL_VARIANT_VARIADIC_LIMIT_E
#define BSLSTL_VARIANT_VARIADIC_LIMIT_E BSLSTL_VARIANT_VARIADIC_LIMIT
#endif
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 0
template <class t_HEAD>
bool operator==(const variant<t_HEAD>& lhs,
                const variant<t_HEAD>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 1
template <class t_HEAD, class t_TAIL_01>
bool operator==(const variant<t_HEAD, t_TAIL_01>& lhs,
                const variant<t_HEAD, t_TAIL_01>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
bool operator==(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
bool operator==(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
bool operator==(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
bool operator==(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
bool operator==(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
bool operator==(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
bool operator==(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
bool operator==(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
bool operator==(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
bool operator==(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
bool operator==(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
bool operator==(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
bool operator==(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
bool operator==(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
bool operator==(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
bool operator==(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16,
                                      t_TAIL_17>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16,
                                      t_TAIL_17>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
bool operator==(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16,
                                      t_TAIL_17,
                                      t_TAIL_18>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16,
                                      t_TAIL_17,
                                      t_TAIL_18>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 0
template <class t_HEAD>
bool operator!=(const variant<t_HEAD>& lhs,
                const variant<t_HEAD>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 1
template <class t_HEAD, class t_TAIL_01>
bool operator!=(const variant<t_HEAD, t_TAIL_01>& lhs,
                const variant<t_HEAD, t_TAIL_01>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
bool operator!=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
bool operator!=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
bool operator!=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
bool operator!=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
bool operator!=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
bool operator!=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
bool operator!=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
bool operator!=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
bool operator!=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
bool operator!=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
bool operator!=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
bool operator!=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
bool operator!=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
bool operator!=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
bool operator!=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
bool operator!=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16,
                                      t_TAIL_17>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16,
                                      t_TAIL_17>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
bool operator!=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16,
                                      t_TAIL_17,
                                      t_TAIL_18>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16,
                                      t_TAIL_17,
                                      t_TAIL_18>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 0
template <class t_HEAD>
bool operator<(const variant<t_HEAD>& lhs,
               const variant<t_HEAD>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 1
template <class t_HEAD, class t_TAIL_01>
bool operator<(const variant<t_HEAD, t_TAIL_01>& lhs,
               const variant<t_HEAD, t_TAIL_01>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
bool operator<(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
bool operator<(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
bool operator<(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
bool operator<(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
bool operator<(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
bool operator<(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
bool operator<(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
bool operator<(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
bool operator<(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
bool operator<(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
bool operator<(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
bool operator<(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
bool operator<(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
bool operator<(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14,
                                     t_TAIL_15>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14,
                                     t_TAIL_15>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
bool operator<(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14,
                                     t_TAIL_15,
                                     t_TAIL_16>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14,
                                     t_TAIL_15,
                                     t_TAIL_16>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
bool operator<(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14,
                                     t_TAIL_15,
                                     t_TAIL_16,
                                     t_TAIL_17>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14,
                                     t_TAIL_15,
                                     t_TAIL_16,
                                     t_TAIL_17>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
bool operator<(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14,
                                     t_TAIL_15,
                                     t_TAIL_16,
                                     t_TAIL_17,
                                     t_TAIL_18>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14,
                                     t_TAIL_15,
                                     t_TAIL_16,
                                     t_TAIL_17,
                                     t_TAIL_18>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 0
template <class t_HEAD>
bool operator>(const variant<t_HEAD>& lhs,
               const variant<t_HEAD>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 1
template <class t_HEAD, class t_TAIL_01>
bool operator>(const variant<t_HEAD, t_TAIL_01>& lhs,
               const variant<t_HEAD, t_TAIL_01>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
bool operator>(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
bool operator>(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
bool operator>(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
bool operator>(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
bool operator>(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
bool operator>(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
bool operator>(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
bool operator>(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
bool operator>(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
bool operator>(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
bool operator>(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
bool operator>(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
bool operator>(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
bool operator>(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14,
                                     t_TAIL_15>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14,
                                     t_TAIL_15>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
bool operator>(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14,
                                     t_TAIL_15,
                                     t_TAIL_16>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14,
                                     t_TAIL_15,
                                     t_TAIL_16>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
bool operator>(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14,
                                     t_TAIL_15,
                                     t_TAIL_16,
                                     t_TAIL_17>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14,
                                     t_TAIL_15,
                                     t_TAIL_16,
                                     t_TAIL_17>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
bool operator>(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14,
                                     t_TAIL_15,
                                     t_TAIL_16,
                                     t_TAIL_17,
                                     t_TAIL_18>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14,
                                     t_TAIL_15,
                                     t_TAIL_16,
                                     t_TAIL_17,
                                     t_TAIL_18>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 0
template <class t_HEAD>
bool operator<=(const variant<t_HEAD>& lhs,
                const variant<t_HEAD>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 1
template <class t_HEAD, class t_TAIL_01>
bool operator<=(const variant<t_HEAD, t_TAIL_01>& lhs,
                const variant<t_HEAD, t_TAIL_01>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
bool operator<=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
bool operator<=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
bool operator<=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
bool operator<=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
bool operator<=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
bool operator<=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
bool operator<=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
bool operator<=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
bool operator<=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
bool operator<=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
bool operator<=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
bool operator<=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
bool operator<=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
bool operator<=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
bool operator<=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
bool operator<=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16,
                                      t_TAIL_17>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16,
                                      t_TAIL_17>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
bool operator<=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16,
                                      t_TAIL_17,
                                      t_TAIL_18>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16,
                                      t_TAIL_17,
                                      t_TAIL_18>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 0
template <class t_HEAD>
bool operator>=(const variant<t_HEAD>& lhs,
                const variant<t_HEAD>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 1
template <class t_HEAD, class t_TAIL_01>
bool operator>=(const variant<t_HEAD, t_TAIL_01>& lhs,
                const variant<t_HEAD, t_TAIL_01>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
bool operator>=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
bool operator>=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
bool operator>=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
bool operator>=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
bool operator>=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
bool operator>=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
bool operator>=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
bool operator>=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
bool operator>=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
bool operator>=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
bool operator>=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
bool operator>=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
bool operator>=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
bool operator>=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
bool operator>=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
bool operator>=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16,
                                      t_TAIL_17>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16,
                                      t_TAIL_17>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
bool operator>=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16,
                                      t_TAIL_17,
                                      t_TAIL_18>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16,
                                      t_TAIL_17,
                                      t_TAIL_18>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 18
 
 
#if defined BSLS_COMPILERFEATURES_SUPPORT_THREE_WAY_COMPARISON &&             \
    defined BSLS_LIBRARYFEATURES_HAS_CPP20_CONCEPTS
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 0
requires()
constexpr std::common_comparison_category_t<
    >
operator<=>(const variant<>& lhs, const variant<>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 1
template <class t_ALTS_01>
    requires(std::three_way_comparable<t_ALTS_01> && )
constexpr std::common_comparison_category_t<
    std::compare_three_way_result_t<t_ALTS_01>>
operator<=>(const variant<t_ALTS_01>& lhs, const variant<t_ALTS_01>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 2
template <class t_ALTS_01,
          class t_ALTS_02>
    requires(std::three_way_comparable<t_ALTS_01> && ,
             std::three_way_comparable<t_ALTS_02> && )
constexpr std::common_comparison_category_t<
    std::compare_three_way_result_t<t_ALTS_01>,
    std::compare_three_way_result_t<t_ALTS_02>>
operator<=>(const variant<t_ALTS_01,
                          t_ALTS_02>& lhs, const variant<t_ALTS_01,
                                                         t_ALTS_02>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 3
template <class t_ALTS_01,
          class t_ALTS_02,
          class t_ALTS_03>
    requires(std::three_way_comparable<t_ALTS_01> && ,
             std::three_way_comparable<t_ALTS_02> && ,
             std::three_way_comparable<t_ALTS_03> && )
constexpr std::common_comparison_category_t<
    std::compare_three_way_result_t<t_ALTS_01>,
    std::compare_three_way_result_t<t_ALTS_02>,
    std::compare_three_way_result_t<t_ALTS_03>>
operator<=>(const variant<t_ALTS_01,
                          t_ALTS_02,
                          t_ALTS_03>& lhs, const variant<t_ALTS_01,
                                                         t_ALTS_02,
                                                         t_ALTS_03>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 4
template <class t_ALTS_01,
          class t_ALTS_02,
          class t_ALTS_03,
          class t_ALTS_04>
    requires(std::three_way_comparable<t_ALTS_01> && ,
             std::three_way_comparable<t_ALTS_02> && ,
             std::three_way_comparable<t_ALTS_03> && ,
             std::three_way_comparable<t_ALTS_04> && )
constexpr std::common_comparison_category_t<
    std::compare_three_way_result_t<t_ALTS_01>,
    std::compare_three_way_result_t<t_ALTS_02>,
    std::compare_three_way_result_t<t_ALTS_03>,
    std::compare_three_way_result_t<t_ALTS_04>>
operator<=>(const variant<t_ALTS_01,
                          t_ALTS_02,
                          t_ALTS_03,
                          t_ALTS_04>& lhs, const variant<t_ALTS_01,
                                                         t_ALTS_02,
                                                         t_ALTS_03,
                                                         t_ALTS_04>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 5
template <class t_ALTS_01,
          class t_ALTS_02,
          class t_ALTS_03,
          class t_ALTS_04,
          class t_ALTS_05>
    requires(std::three_way_comparable<t_ALTS_01> && ,
             std::three_way_comparable<t_ALTS_02> && ,
             std::three_way_comparable<t_ALTS_03> && ,
             std::three_way_comparable<t_ALTS_04> && ,
             std::three_way_comparable<t_ALTS_05> && )
constexpr std::common_comparison_category_t<
    std::compare_three_way_result_t<t_ALTS_01>,
    std::compare_three_way_result_t<t_ALTS_02>,
    std::compare_three_way_result_t<t_ALTS_03>,
    std::compare_three_way_result_t<t_ALTS_04>,
    std::compare_three_way_result_t<t_ALTS_05>>
operator<=>(const variant<t_ALTS_01,
                          t_ALTS_02,
                          t_ALTS_03,
                          t_ALTS_04,
                          t_ALTS_05>& lhs, const variant<t_ALTS_01,
                                                         t_ALTS_02,
                                                         t_ALTS_03,
                                                         t_ALTS_04,
                                                         t_ALTS_05>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 6
template <class t_ALTS_01,
          class t_ALTS_02,
          class t_ALTS_03,
          class t_ALTS_04,
          class t_ALTS_05,
          class t_ALTS_06>
    requires(std::three_way_comparable<t_ALTS_01> && ,
             std::three_way_comparable<t_ALTS_02> && ,
             std::three_way_comparable<t_ALTS_03> && ,
             std::three_way_comparable<t_ALTS_04> && ,
             std::three_way_comparable<t_ALTS_05> && ,
             std::three_way_comparable<t_ALTS_06> && )
constexpr std::common_comparison_category_t<
    std::compare_three_way_result_t<t_ALTS_01>,
    std::compare_three_way_result_t<t_ALTS_02>,
    std::compare_three_way_result_t<t_ALTS_03>,
    std::compare_three_way_result_t<t_ALTS_04>,
    std::compare_three_way_result_t<t_ALTS_05>,
    std::compare_three_way_result_t<t_ALTS_06>>
operator<=>(const variant<t_ALTS_01,
                          t_ALTS_02,
                          t_ALTS_03,
                          t_ALTS_04,
                          t_ALTS_05,
                          t_ALTS_06>& lhs, const variant<t_ALTS_01,
                                                         t_ALTS_02,
                                                         t_ALTS_03,
                                                         t_ALTS_04,
                                                         t_ALTS_05,
                                                         t_ALTS_06>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 7
template <class t_ALTS_01,
          class t_ALTS_02,
          class t_ALTS_03,
          class t_ALTS_04,
          class t_ALTS_05,
          class t_ALTS_06,
          class t_ALTS_07>
    requires(std::three_way_comparable<t_ALTS_01> && ,
             std::three_way_comparable<t_ALTS_02> && ,
             std::three_way_comparable<t_ALTS_03> && ,
             std::three_way_comparable<t_ALTS_04> && ,
             std::three_way_comparable<t_ALTS_05> && ,
             std::three_way_comparable<t_ALTS_06> && ,
             std::three_way_comparable<t_ALTS_07> && )
constexpr std::common_comparison_category_t<
    std::compare_three_way_result_t<t_ALTS_01>,
    std::compare_three_way_result_t<t_ALTS_02>,
    std::compare_three_way_result_t<t_ALTS_03>,
    std::compare_three_way_result_t<t_ALTS_04>,
    std::compare_three_way_result_t<t_ALTS_05>,
    std::compare_three_way_result_t<t_ALTS_06>,
    std::compare_three_way_result_t<t_ALTS_07>>
operator<=>(const variant<t_ALTS_01,
                          t_ALTS_02,
                          t_ALTS_03,
                          t_ALTS_04,
                          t_ALTS_05,
                          t_ALTS_06,
                          t_ALTS_07>& lhs, const variant<t_ALTS_01,
                                                         t_ALTS_02,
                                                         t_ALTS_03,
                                                         t_ALTS_04,
                                                         t_ALTS_05,
                                                         t_ALTS_06,
                                                         t_ALTS_07>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 8
template <class t_ALTS_01,
          class t_ALTS_02,
          class t_ALTS_03,
          class t_ALTS_04,
          class t_ALTS_05,
          class t_ALTS_06,
          class t_ALTS_07,
          class t_ALTS_08>
    requires(std::three_way_comparable<t_ALTS_01> && ,
             std::three_way_comparable<t_ALTS_02> && ,
             std::three_way_comparable<t_ALTS_03> && ,
             std::three_way_comparable<t_ALTS_04> && ,
             std::three_way_comparable<t_ALTS_05> && ,
             std::three_way_comparable<t_ALTS_06> && ,
             std::three_way_comparable<t_ALTS_07> && ,
             std::three_way_comparable<t_ALTS_08> && )
constexpr std::common_comparison_category_t<
    std::compare_three_way_result_t<t_ALTS_01>,
    std::compare_three_way_result_t<t_ALTS_02>,
    std::compare_three_way_result_t<t_ALTS_03>,
    std::compare_three_way_result_t<t_ALTS_04>,
    std::compare_three_way_result_t<t_ALTS_05>,
    std::compare_three_way_result_t<t_ALTS_06>,
    std::compare_three_way_result_t<t_ALTS_07>,
    std::compare_three_way_result_t<t_ALTS_08>>
operator<=>(const variant<t_ALTS_01,
                          t_ALTS_02,
                          t_ALTS_03,
                          t_ALTS_04,
                          t_ALTS_05,
                          t_ALTS_06,
                          t_ALTS_07,
                          t_ALTS_08>& lhs, const variant<t_ALTS_01,
                                                         t_ALTS_02,
                                                         t_ALTS_03,
                                                         t_ALTS_04,
                                                         t_ALTS_05,
                                                         t_ALTS_06,
                                                         t_ALTS_07,
                                                         t_ALTS_08>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 9
template <class t_ALTS_01,
          class t_ALTS_02,
          class t_ALTS_03,
          class t_ALTS_04,
          class t_ALTS_05,
          class t_ALTS_06,
          class t_ALTS_07,
          class t_ALTS_08,
          class t_ALTS_09>
    requires(std::three_way_comparable<t_ALTS_01> && ,
             std::three_way_comparable<t_ALTS_02> && ,
             std::three_way_comparable<t_ALTS_03> && ,
             std::three_way_comparable<t_ALTS_04> && ,
             std::three_way_comparable<t_ALTS_05> && ,
             std::three_way_comparable<t_ALTS_06> && ,
             std::three_way_comparable<t_ALTS_07> && ,
             std::three_way_comparable<t_ALTS_08> && ,
             std::three_way_comparable<t_ALTS_09> && )
constexpr std::common_comparison_category_t<
    std::compare_three_way_result_t<t_ALTS_01>,
    std::compare_three_way_result_t<t_ALTS_02>,
    std::compare_three_way_result_t<t_ALTS_03>,
    std::compare_three_way_result_t<t_ALTS_04>,
    std::compare_three_way_result_t<t_ALTS_05>,
    std::compare_three_way_result_t<t_ALTS_06>,
    std::compare_three_way_result_t<t_ALTS_07>,
    std::compare_three_way_result_t<t_ALTS_08>,
    std::compare_three_way_result_t<t_ALTS_09>>
operator<=>(const variant<t_ALTS_01,
                          t_ALTS_02,
                          t_ALTS_03,
                          t_ALTS_04,
                          t_ALTS_05,
                          t_ALTS_06,
                          t_ALTS_07,
                          t_ALTS_08,
                          t_ALTS_09>& lhs, const variant<t_ALTS_01,
                                                         t_ALTS_02,
                                                         t_ALTS_03,
                                                         t_ALTS_04,
                                                         t_ALTS_05,
                                                         t_ALTS_06,
                                                         t_ALTS_07,
                                                         t_ALTS_08,
                                                         t_ALTS_09>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 10
template <class t_ALTS_01,
          class t_ALTS_02,
          class t_ALTS_03,
          class t_ALTS_04,
          class t_ALTS_05,
          class t_ALTS_06,
          class t_ALTS_07,
          class t_ALTS_08,
          class t_ALTS_09,
          class t_ALTS_10>
    requires(std::three_way_comparable<t_ALTS_01> && ,
             std::three_way_comparable<t_ALTS_02> && ,
             std::three_way_comparable<t_ALTS_03> && ,
             std::three_way_comparable<t_ALTS_04> && ,
             std::three_way_comparable<t_ALTS_05> && ,
             std::three_way_comparable<t_ALTS_06> && ,
             std::three_way_comparable<t_ALTS_07> && ,
             std::three_way_comparable<t_ALTS_08> && ,
             std::three_way_comparable<t_ALTS_09> && ,
             std::three_way_comparable<t_ALTS_10> && )
constexpr std::common_comparison_category_t<
    std::compare_three_way_result_t<t_ALTS_01>,
    std::compare_three_way_result_t<t_ALTS_02>,
    std::compare_three_way_result_t<t_ALTS_03>,
    std::compare_three_way_result_t<t_ALTS_04>,
    std::compare_three_way_result_t<t_ALTS_05>,
    std::compare_three_way_result_t<t_ALTS_06>,
    std::compare_three_way_result_t<t_ALTS_07>,
    std::compare_three_way_result_t<t_ALTS_08>,
    std::compare_three_way_result_t<t_ALTS_09>,
    std::compare_three_way_result_t<t_ALTS_10>>
operator<=>(const variant<t_ALTS_01,
                          t_ALTS_02,
                          t_ALTS_03,
                          t_ALTS_04,
                          t_ALTS_05,
                          t_ALTS_06,
                          t_ALTS_07,
                          t_ALTS_08,
                          t_ALTS_09,
                          t_ALTS_10>& lhs, const variant<t_ALTS_01,
                                                         t_ALTS_02,
                                                         t_ALTS_03,
                                                         t_ALTS_04,
                                                         t_ALTS_05,
                                                         t_ALTS_06,
                                                         t_ALTS_07,
                                                         t_ALTS_08,
                                                         t_ALTS_09,
                                                         t_ALTS_10>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 11
template <class t_ALTS_01,
          class t_ALTS_02,
          class t_ALTS_03,
          class t_ALTS_04,
          class t_ALTS_05,
          class t_ALTS_06,
          class t_ALTS_07,
          class t_ALTS_08,
          class t_ALTS_09,
          class t_ALTS_10,
          class t_ALTS_11>
    requires(std::three_way_comparable<t_ALTS_01> && ,
             std::three_way_comparable<t_ALTS_02> && ,
             std::three_way_comparable<t_ALTS_03> && ,
             std::three_way_comparable<t_ALTS_04> && ,
             std::three_way_comparable<t_ALTS_05> && ,
             std::three_way_comparable<t_ALTS_06> && ,
             std::three_way_comparable<t_ALTS_07> && ,
             std::three_way_comparable<t_ALTS_08> && ,
             std::three_way_comparable<t_ALTS_09> && ,
             std::three_way_comparable<t_ALTS_10> && ,
             std::three_way_comparable<t_ALTS_11> && )
constexpr std::common_comparison_category_t<
    std::compare_three_way_result_t<t_ALTS_01>,
    std::compare_three_way_result_t<t_ALTS_02>,
    std::compare_three_way_result_t<t_ALTS_03>,
    std::compare_three_way_result_t<t_ALTS_04>,
    std::compare_three_way_result_t<t_ALTS_05>,
    std::compare_three_way_result_t<t_ALTS_06>,
    std::compare_three_way_result_t<t_ALTS_07>,
    std::compare_three_way_result_t<t_ALTS_08>,
    std::compare_three_way_result_t<t_ALTS_09>,
    std::compare_three_way_result_t<t_ALTS_10>,
    std::compare_three_way_result_t<t_ALTS_11>>
operator<=>(const variant<t_ALTS_01,
                          t_ALTS_02,
                          t_ALTS_03,
                          t_ALTS_04,
                          t_ALTS_05,
                          t_ALTS_06,
                          t_ALTS_07,
                          t_ALTS_08,
                          t_ALTS_09,
                          t_ALTS_10,
                          t_ALTS_11>& lhs, const variant<t_ALTS_01,
                                                         t_ALTS_02,
                                                         t_ALTS_03,
                                                         t_ALTS_04,
                                                         t_ALTS_05,
                                                         t_ALTS_06,
                                                         t_ALTS_07,
                                                         t_ALTS_08,
                                                         t_ALTS_09,
                                                         t_ALTS_10,
                                                         t_ALTS_11>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 12
template <class t_ALTS_01,
          class t_ALTS_02,
          class t_ALTS_03,
          class t_ALTS_04,
          class t_ALTS_05,
          class t_ALTS_06,
          class t_ALTS_07,
          class t_ALTS_08,
          class t_ALTS_09,
          class t_ALTS_10,
          class t_ALTS_11,
          class t_ALTS_12>
    requires(std::three_way_comparable<t_ALTS_01> && ,
             std::three_way_comparable<t_ALTS_02> && ,
             std::three_way_comparable<t_ALTS_03> && ,
             std::three_way_comparable<t_ALTS_04> && ,
             std::three_way_comparable<t_ALTS_05> && ,
             std::three_way_comparable<t_ALTS_06> && ,
             std::three_way_comparable<t_ALTS_07> && ,
             std::three_way_comparable<t_ALTS_08> && ,
             std::three_way_comparable<t_ALTS_09> && ,
             std::three_way_comparable<t_ALTS_10> && ,
             std::three_way_comparable<t_ALTS_11> && ,
             std::three_way_comparable<t_ALTS_12> && )
constexpr std::common_comparison_category_t<
    std::compare_three_way_result_t<t_ALTS_01>,
    std::compare_three_way_result_t<t_ALTS_02>,
    std::compare_three_way_result_t<t_ALTS_03>,
    std::compare_three_way_result_t<t_ALTS_04>,
    std::compare_three_way_result_t<t_ALTS_05>,
    std::compare_three_way_result_t<t_ALTS_06>,
    std::compare_three_way_result_t<t_ALTS_07>,
    std::compare_three_way_result_t<t_ALTS_08>,
    std::compare_three_way_result_t<t_ALTS_09>,
    std::compare_three_way_result_t<t_ALTS_10>,
    std::compare_three_way_result_t<t_ALTS_11>,
    std::compare_three_way_result_t<t_ALTS_12>>
operator<=>(const variant<t_ALTS_01,
                          t_ALTS_02,
                          t_ALTS_03,
                          t_ALTS_04,
                          t_ALTS_05,
                          t_ALTS_06,
                          t_ALTS_07,
                          t_ALTS_08,
                          t_ALTS_09,
                          t_ALTS_10,
                          t_ALTS_11,
                          t_ALTS_12>& lhs, const variant<t_ALTS_01,
                                                         t_ALTS_02,
                                                         t_ALTS_03,
                                                         t_ALTS_04,
                                                         t_ALTS_05,
                                                         t_ALTS_06,
                                                         t_ALTS_07,
                                                         t_ALTS_08,
                                                         t_ALTS_09,
                                                         t_ALTS_10,
                                                         t_ALTS_11,
                                                         t_ALTS_12>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 13
template <class t_ALTS_01,
          class t_ALTS_02,
          class t_ALTS_03,
          class t_ALTS_04,
          class t_ALTS_05,
          class t_ALTS_06,
          class t_ALTS_07,
          class t_ALTS_08,
          class t_ALTS_09,
          class t_ALTS_10,
          class t_ALTS_11,
          class t_ALTS_12,
          class t_ALTS_13>
    requires(std::three_way_comparable<t_ALTS_01> && ,
             std::three_way_comparable<t_ALTS_02> && ,
             std::three_way_comparable<t_ALTS_03> && ,
             std::three_way_comparable<t_ALTS_04> && ,
             std::three_way_comparable<t_ALTS_05> && ,
             std::three_way_comparable<t_ALTS_06> && ,
             std::three_way_comparable<t_ALTS_07> && ,
             std::three_way_comparable<t_ALTS_08> && ,
             std::three_way_comparable<t_ALTS_09> && ,
             std::three_way_comparable<t_ALTS_10> && ,
             std::three_way_comparable<t_ALTS_11> && ,
             std::three_way_comparable<t_ALTS_12> && ,
             std::three_way_comparable<t_ALTS_13> && )
constexpr std::common_comparison_category_t<
    std::compare_three_way_result_t<t_ALTS_01>,
    std::compare_three_way_result_t<t_ALTS_02>,
    std::compare_three_way_result_t<t_ALTS_03>,
    std::compare_three_way_result_t<t_ALTS_04>,
    std::compare_three_way_result_t<t_ALTS_05>,
    std::compare_three_way_result_t<t_ALTS_06>,
    std::compare_three_way_result_t<t_ALTS_07>,
    std::compare_three_way_result_t<t_ALTS_08>,
    std::compare_three_way_result_t<t_ALTS_09>,
    std::compare_three_way_result_t<t_ALTS_10>,
    std::compare_three_way_result_t<t_ALTS_11>,
    std::compare_three_way_result_t<t_ALTS_12>,
    std::compare_three_way_result_t<t_ALTS_13>>
operator<=>(const variant<t_ALTS_01,
                          t_ALTS_02,
                          t_ALTS_03,
                          t_ALTS_04,
                          t_ALTS_05,
                          t_ALTS_06,
                          t_ALTS_07,
                          t_ALTS_08,
                          t_ALTS_09,
                          t_ALTS_10,
                          t_ALTS_11,
                          t_ALTS_12,
                          t_ALTS_13>& lhs, const variant<t_ALTS_01,
                                                         t_ALTS_02,
                                                         t_ALTS_03,
                                                         t_ALTS_04,
                                                         t_ALTS_05,
                                                         t_ALTS_06,
                                                         t_ALTS_07,
                                                         t_ALTS_08,
                                                         t_ALTS_09,
                                                         t_ALTS_10,
                                                         t_ALTS_11,
                                                         t_ALTS_12,
                                                         t_ALTS_13>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 14
template <class t_ALTS_01,
          class t_ALTS_02,
          class t_ALTS_03,
          class t_ALTS_04,
          class t_ALTS_05,
          class t_ALTS_06,
          class t_ALTS_07,
          class t_ALTS_08,
          class t_ALTS_09,
          class t_ALTS_10,
          class t_ALTS_11,
          class t_ALTS_12,
          class t_ALTS_13,
          class t_ALTS_14>
    requires(std::three_way_comparable<t_ALTS_01> && ,
             std::three_way_comparable<t_ALTS_02> && ,
             std::three_way_comparable<t_ALTS_03> && ,
             std::three_way_comparable<t_ALTS_04> && ,
             std::three_way_comparable<t_ALTS_05> && ,
             std::three_way_comparable<t_ALTS_06> && ,
             std::three_way_comparable<t_ALTS_07> && ,
             std::three_way_comparable<t_ALTS_08> && ,
             std::three_way_comparable<t_ALTS_09> && ,
             std::three_way_comparable<t_ALTS_10> && ,
             std::three_way_comparable<t_ALTS_11> && ,
             std::three_way_comparable<t_ALTS_12> && ,
             std::three_way_comparable<t_ALTS_13> && ,
             std::three_way_comparable<t_ALTS_14> && )
constexpr std::common_comparison_category_t<
    std::compare_three_way_result_t<t_ALTS_01>,
    std::compare_three_way_result_t<t_ALTS_02>,
    std::compare_three_way_result_t<t_ALTS_03>,
    std::compare_three_way_result_t<t_ALTS_04>,
    std::compare_three_way_result_t<t_ALTS_05>,
    std::compare_three_way_result_t<t_ALTS_06>,
    std::compare_three_way_result_t<t_ALTS_07>,
    std::compare_three_way_result_t<t_ALTS_08>,
    std::compare_three_way_result_t<t_ALTS_09>,
    std::compare_three_way_result_t<t_ALTS_10>,
    std::compare_three_way_result_t<t_ALTS_11>,
    std::compare_three_way_result_t<t_ALTS_12>,
    std::compare_three_way_result_t<t_ALTS_13>,
    std::compare_three_way_result_t<t_ALTS_14>>
operator<=>(const variant<t_ALTS_01,
                          t_ALTS_02,
                          t_ALTS_03,
                          t_ALTS_04,
                          t_ALTS_05,
                          t_ALTS_06,
                          t_ALTS_07,
                          t_ALTS_08,
                          t_ALTS_09,
                          t_ALTS_10,
                          t_ALTS_11,
                          t_ALTS_12,
                          t_ALTS_13,
                          t_ALTS_14>& lhs, const variant<t_ALTS_01,
                                                         t_ALTS_02,
                                                         t_ALTS_03,
                                                         t_ALTS_04,
                                                         t_ALTS_05,
                                                         t_ALTS_06,
                                                         t_ALTS_07,
                                                         t_ALTS_08,
                                                         t_ALTS_09,
                                                         t_ALTS_10,
                                                         t_ALTS_11,
                                                         t_ALTS_12,
                                                         t_ALTS_13,
                                                         t_ALTS_14>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 15
template <class t_ALTS_01,
          class t_ALTS_02,
          class t_ALTS_03,
          class t_ALTS_04,
          class t_ALTS_05,
          class t_ALTS_06,
          class t_ALTS_07,
          class t_ALTS_08,
          class t_ALTS_09,
          class t_ALTS_10,
          class t_ALTS_11,
          class t_ALTS_12,
          class t_ALTS_13,
          class t_ALTS_14,
          class t_ALTS_15>
    requires(std::three_way_comparable<t_ALTS_01> && ,
             std::three_way_comparable<t_ALTS_02> && ,
             std::three_way_comparable<t_ALTS_03> && ,
             std::three_way_comparable<t_ALTS_04> && ,
             std::three_way_comparable<t_ALTS_05> && ,
             std::three_way_comparable<t_ALTS_06> && ,
             std::three_way_comparable<t_ALTS_07> && ,
             std::three_way_comparable<t_ALTS_08> && ,
             std::three_way_comparable<t_ALTS_09> && ,
             std::three_way_comparable<t_ALTS_10> && ,
             std::three_way_comparable<t_ALTS_11> && ,
             std::three_way_comparable<t_ALTS_12> && ,
             std::three_way_comparable<t_ALTS_13> && ,
             std::three_way_comparable<t_ALTS_14> && ,
             std::three_way_comparable<t_ALTS_15> && )
constexpr std::common_comparison_category_t<
    std::compare_three_way_result_t<t_ALTS_01>,
    std::compare_three_way_result_t<t_ALTS_02>,
    std::compare_three_way_result_t<t_ALTS_03>,
    std::compare_three_way_result_t<t_ALTS_04>,
    std::compare_three_way_result_t<t_ALTS_05>,
    std::compare_three_way_result_t<t_ALTS_06>,
    std::compare_three_way_result_t<t_ALTS_07>,
    std::compare_three_way_result_t<t_ALTS_08>,
    std::compare_three_way_result_t<t_ALTS_09>,
    std::compare_three_way_result_t<t_ALTS_10>,
    std::compare_three_way_result_t<t_ALTS_11>,
    std::compare_three_way_result_t<t_ALTS_12>,
    std::compare_three_way_result_t<t_ALTS_13>,
    std::compare_three_way_result_t<t_ALTS_14>,
    std::compare_three_way_result_t<t_ALTS_15>>
operator<=>(const variant<t_ALTS_01,
                          t_ALTS_02,
                          t_ALTS_03,
                          t_ALTS_04,
                          t_ALTS_05,
                          t_ALTS_06,
                          t_ALTS_07,
                          t_ALTS_08,
                          t_ALTS_09,
                          t_ALTS_10,
                          t_ALTS_11,
                          t_ALTS_12,
                          t_ALTS_13,
                          t_ALTS_14,
                          t_ALTS_15>& lhs, const variant<t_ALTS_01,
                                                         t_ALTS_02,
                                                         t_ALTS_03,
                                                         t_ALTS_04,
                                                         t_ALTS_05,
                                                         t_ALTS_06,
                                                         t_ALTS_07,
                                                         t_ALTS_08,
                                                         t_ALTS_09,
                                                         t_ALTS_10,
                                                         t_ALTS_11,
                                                         t_ALTS_12,
                                                         t_ALTS_13,
                                                         t_ALTS_14,
                                                         t_ALTS_15>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 16
template <class t_ALTS_01,
          class t_ALTS_02,
          class t_ALTS_03,
          class t_ALTS_04,
          class t_ALTS_05,
          class t_ALTS_06,
          class t_ALTS_07,
          class t_ALTS_08,
          class t_ALTS_09,
          class t_ALTS_10,
          class t_ALTS_11,
          class t_ALTS_12,
          class t_ALTS_13,
          class t_ALTS_14,
          class t_ALTS_15,
          class t_ALTS_16>
    requires(std::three_way_comparable<t_ALTS_01> && ,
             std::three_way_comparable<t_ALTS_02> && ,
             std::three_way_comparable<t_ALTS_03> && ,
             std::three_way_comparable<t_ALTS_04> && ,
             std::three_way_comparable<t_ALTS_05> && ,
             std::three_way_comparable<t_ALTS_06> && ,
             std::three_way_comparable<t_ALTS_07> && ,
             std::three_way_comparable<t_ALTS_08> && ,
             std::three_way_comparable<t_ALTS_09> && ,
             std::three_way_comparable<t_ALTS_10> && ,
             std::three_way_comparable<t_ALTS_11> && ,
             std::three_way_comparable<t_ALTS_12> && ,
             std::three_way_comparable<t_ALTS_13> && ,
             std::three_way_comparable<t_ALTS_14> && ,
             std::three_way_comparable<t_ALTS_15> && ,
             std::three_way_comparable<t_ALTS_16> && )
constexpr std::common_comparison_category_t<
    std::compare_three_way_result_t<t_ALTS_01>,
    std::compare_three_way_result_t<t_ALTS_02>,
    std::compare_three_way_result_t<t_ALTS_03>,
    std::compare_three_way_result_t<t_ALTS_04>,
    std::compare_three_way_result_t<t_ALTS_05>,
    std::compare_three_way_result_t<t_ALTS_06>,
    std::compare_three_way_result_t<t_ALTS_07>,
    std::compare_three_way_result_t<t_ALTS_08>,
    std::compare_three_way_result_t<t_ALTS_09>,
    std::compare_three_way_result_t<t_ALTS_10>,
    std::compare_three_way_result_t<t_ALTS_11>,
    std::compare_three_way_result_t<t_ALTS_12>,
    std::compare_three_way_result_t<t_ALTS_13>,
    std::compare_three_way_result_t<t_ALTS_14>,
    std::compare_three_way_result_t<t_ALTS_15>,
    std::compare_three_way_result_t<t_ALTS_16>>
operator<=>(const variant<t_ALTS_01,
                          t_ALTS_02,
                          t_ALTS_03,
                          t_ALTS_04,
                          t_ALTS_05,
                          t_ALTS_06,
                          t_ALTS_07,
                          t_ALTS_08,
                          t_ALTS_09,
                          t_ALTS_10,
                          t_ALTS_11,
                          t_ALTS_12,
                          t_ALTS_13,
                          t_ALTS_14,
                          t_ALTS_15,
                          t_ALTS_16>& lhs, const variant<t_ALTS_01,
                                                         t_ALTS_02,
                                                         t_ALTS_03,
                                                         t_ALTS_04,
                                                         t_ALTS_05,
                                                         t_ALTS_06,
                                                         t_ALTS_07,
                                                         t_ALTS_08,
                                                         t_ALTS_09,
                                                         t_ALTS_10,
                                                         t_ALTS_11,
                                                         t_ALTS_12,
                                                         t_ALTS_13,
                                                         t_ALTS_14,
                                                         t_ALTS_15,
                                                         t_ALTS_16>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 17
template <class t_ALTS_01,
          class t_ALTS_02,
          class t_ALTS_03,
          class t_ALTS_04,
          class t_ALTS_05,
          class t_ALTS_06,
          class t_ALTS_07,
          class t_ALTS_08,
          class t_ALTS_09,
          class t_ALTS_10,
          class t_ALTS_11,
          class t_ALTS_12,
          class t_ALTS_13,
          class t_ALTS_14,
          class t_ALTS_15,
          class t_ALTS_16,
          class t_ALTS_17>
    requires(std::three_way_comparable<t_ALTS_01> && ,
             std::three_way_comparable<t_ALTS_02> && ,
             std::three_way_comparable<t_ALTS_03> && ,
             std::three_way_comparable<t_ALTS_04> && ,
             std::three_way_comparable<t_ALTS_05> && ,
             std::three_way_comparable<t_ALTS_06> && ,
             std::three_way_comparable<t_ALTS_07> && ,
             std::three_way_comparable<t_ALTS_08> && ,
             std::three_way_comparable<t_ALTS_09> && ,
             std::three_way_comparable<t_ALTS_10> && ,
             std::three_way_comparable<t_ALTS_11> && ,
             std::three_way_comparable<t_ALTS_12> && ,
             std::three_way_comparable<t_ALTS_13> && ,
             std::three_way_comparable<t_ALTS_14> && ,
             std::three_way_comparable<t_ALTS_15> && ,
             std::three_way_comparable<t_ALTS_16> && ,
             std::three_way_comparable<t_ALTS_17> && )
constexpr std::common_comparison_category_t<
    std::compare_three_way_result_t<t_ALTS_01>,
    std::compare_three_way_result_t<t_ALTS_02>,
    std::compare_three_way_result_t<t_ALTS_03>,
    std::compare_three_way_result_t<t_ALTS_04>,
    std::compare_three_way_result_t<t_ALTS_05>,
    std::compare_three_way_result_t<t_ALTS_06>,
    std::compare_three_way_result_t<t_ALTS_07>,
    std::compare_three_way_result_t<t_ALTS_08>,
    std::compare_three_way_result_t<t_ALTS_09>,
    std::compare_three_way_result_t<t_ALTS_10>,
    std::compare_three_way_result_t<t_ALTS_11>,
    std::compare_three_way_result_t<t_ALTS_12>,
    std::compare_three_way_result_t<t_ALTS_13>,
    std::compare_three_way_result_t<t_ALTS_14>,
    std::compare_three_way_result_t<t_ALTS_15>,
    std::compare_three_way_result_t<t_ALTS_16>,
    std::compare_three_way_result_t<t_ALTS_17>>
operator<=>(const variant<t_ALTS_01,
                          t_ALTS_02,
                          t_ALTS_03,
                          t_ALTS_04,
                          t_ALTS_05,
                          t_ALTS_06,
                          t_ALTS_07,
                          t_ALTS_08,
                          t_ALTS_09,
                          t_ALTS_10,
                          t_ALTS_11,
                          t_ALTS_12,
                          t_ALTS_13,
                          t_ALTS_14,
                          t_ALTS_15,
                          t_ALTS_16,
                          t_ALTS_17>& lhs, const variant<t_ALTS_01,
                                                         t_ALTS_02,
                                                         t_ALTS_03,
                                                         t_ALTS_04,
                                                         t_ALTS_05,
                                                         t_ALTS_06,
                                                         t_ALTS_07,
                                                         t_ALTS_08,
                                                         t_ALTS_09,
                                                         t_ALTS_10,
                                                         t_ALTS_11,
                                                         t_ALTS_12,
                                                         t_ALTS_13,
                                                         t_ALTS_14,
                                                         t_ALTS_15,
                                                         t_ALTS_16,
                                                         t_ALTS_17>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 18
template <class t_ALTS_01,
          class t_ALTS_02,
          class t_ALTS_03,
          class t_ALTS_04,
          class t_ALTS_05,
          class t_ALTS_06,
          class t_ALTS_07,
          class t_ALTS_08,
          class t_ALTS_09,
          class t_ALTS_10,
          class t_ALTS_11,
          class t_ALTS_12,
          class t_ALTS_13,
          class t_ALTS_14,
          class t_ALTS_15,
          class t_ALTS_16,
          class t_ALTS_17,
          class t_ALTS_18>
    requires(std::three_way_comparable<t_ALTS_01> && ,
             std::three_way_comparable<t_ALTS_02> && ,
             std::three_way_comparable<t_ALTS_03> && ,
             std::three_way_comparable<t_ALTS_04> && ,
             std::three_way_comparable<t_ALTS_05> && ,
             std::three_way_comparable<t_ALTS_06> && ,
             std::three_way_comparable<t_ALTS_07> && ,
             std::three_way_comparable<t_ALTS_08> && ,
             std::three_way_comparable<t_ALTS_09> && ,
             std::three_way_comparable<t_ALTS_10> && ,
             std::three_way_comparable<t_ALTS_11> && ,
             std::three_way_comparable<t_ALTS_12> && ,
             std::three_way_comparable<t_ALTS_13> && ,
             std::three_way_comparable<t_ALTS_14> && ,
             std::three_way_comparable<t_ALTS_15> && ,
             std::three_way_comparable<t_ALTS_16> && ,
             std::three_way_comparable<t_ALTS_17> && ,
             std::three_way_comparable<t_ALTS_18> && )
constexpr std::common_comparison_category_t<
    std::compare_three_way_result_t<t_ALTS_01>,
    std::compare_three_way_result_t<t_ALTS_02>,
    std::compare_three_way_result_t<t_ALTS_03>,
    std::compare_three_way_result_t<t_ALTS_04>,
    std::compare_three_way_result_t<t_ALTS_05>,
    std::compare_three_way_result_t<t_ALTS_06>,
    std::compare_three_way_result_t<t_ALTS_07>,
    std::compare_three_way_result_t<t_ALTS_08>,
    std::compare_three_way_result_t<t_ALTS_09>,
    std::compare_three_way_result_t<t_ALTS_10>,
    std::compare_three_way_result_t<t_ALTS_11>,
    std::compare_three_way_result_t<t_ALTS_12>,
    std::compare_three_way_result_t<t_ALTS_13>,
    std::compare_three_way_result_t<t_ALTS_14>,
    std::compare_three_way_result_t<t_ALTS_15>,
    std::compare_three_way_result_t<t_ALTS_16>,
    std::compare_three_way_result_t<t_ALTS_17>,
    std::compare_three_way_result_t<t_ALTS_18>>
operator<=>(const variant<t_ALTS_01,
                          t_ALTS_02,
                          t_ALTS_03,
                          t_ALTS_04,
                          t_ALTS_05,
                          t_ALTS_06,
                          t_ALTS_07,
                          t_ALTS_08,
                          t_ALTS_09,
                          t_ALTS_10,
                          t_ALTS_11,
                          t_ALTS_12,
                          t_ALTS_13,
                          t_ALTS_14,
                          t_ALTS_15,
                          t_ALTS_16,
                          t_ALTS_17,
                          t_ALTS_18>& lhs, const variant<t_ALTS_01,
                                                         t_ALTS_02,
                                                         t_ALTS_03,
                                                         t_ALTS_04,
                                                         t_ALTS_05,
                                                         t_ALTS_06,
                                                         t_ALTS_07,
                                                         t_ALTS_08,
                                                         t_ALTS_09,
                                                         t_ALTS_10,
                                                         t_ALTS_11,
                                                         t_ALTS_12,
                                                         t_ALTS_13,
                                                         t_ALTS_14,
                                                         t_ALTS_15,
                                                         t_ALTS_16,
                                                         t_ALTS_17,
                                                         t_ALTS_18>& rhs);
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_E >= 18
 
#endif
#else
// The generated code below is a workaround for the absence of perfect
// forwarding in some compilers.
template <class t_HEAD, class... t_TAIL>
bool operator==(const variant<t_HEAD, t_TAIL...>& lhs,
                const variant<t_HEAD, t_TAIL...>& rhs);
 
template <class t_HEAD, class... t_TAIL>
bool operator!=(const variant<t_HEAD, t_TAIL...>& lhs,
                const variant<t_HEAD, t_TAIL...>& rhs);
 
template <class t_HEAD, class... t_TAIL>
bool operator<(const variant<t_HEAD, t_TAIL...>& lhs,
               const variant<t_HEAD, t_TAIL...>& rhs);
 
template <class t_HEAD, class... t_TAIL>
bool operator>(const variant<t_HEAD, t_TAIL...>& lhs,
               const variant<t_HEAD, t_TAIL...>& rhs);
 
template <class t_HEAD, class... t_TAIL>
bool operator<=(const variant<t_HEAD, t_TAIL...>& lhs,
                const variant<t_HEAD, t_TAIL...>& rhs);
 
template <class t_HEAD, class... t_TAIL>
bool operator>=(const variant<t_HEAD, t_TAIL...>& lhs,
                const variant<t_HEAD, t_TAIL...>& rhs);
 
#if defined BSLS_COMPILERFEATURES_SUPPORT_THREE_WAY_COMPARISON &&             \
    defined BSLS_LIBRARYFEATURES_HAS_CPP20_CONCEPTS
 
template <class... t_ALTS>
    requires(std::three_way_comparable<t_ALTS> && ...)
constexpr std::common_comparison_category_t<
    std::compare_three_way_result_t<t_ALTS>...>
operator<=>(const variant<t_ALTS...>& lhs, const variant<t_ALTS...>& rhs);
#endif
// }}} END GENERATED CODE
#endif
 
}  // close namespace bsl
 
 
namespace bslstl {
// COMPONENT-PRIVATE TAG TYPES
 
/// This component-private tag type is used as a parameter type for
/// constructors of `Variant_Base` that accept a `std::variant`.
struct Variant_ConstructFromStdTag {};
 
#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
// {{{ BEGIN GENERATED CODE
// Command line: sim_cpp11_features.pl bslstl_variant.h
#ifndef BSLSTL_VARIANT_VARIADIC_LIMIT
#define BSLSTL_VARIANT_VARIADIC_LIMIT 18
#endif
#ifndef BSLSTL_VARIANT_VARIADIC_LIMIT_F
#define BSLSTL_VARIANT_VARIADIC_LIMIT_F BSLSTL_VARIANT_VARIADIC_LIMIT
#endif
template <class t_HEAD = BSLSTL_VARIANT_NOT_A_TYPE
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 0
        , class t_TAIL_0 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 1
        , class t_TAIL_1 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 2
        , class t_TAIL_2 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 3
        , class t_TAIL_3 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 4
        , class t_TAIL_4 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 5
        , class t_TAIL_5 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 6
        , class t_TAIL_6 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 7
        , class t_TAIL_7 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 8
        , class t_TAIL_8 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 9
        , class t_TAIL_9 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 10
        , class t_TAIL_10 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 11
        , class t_TAIL_11 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 12
        , class t_TAIL_12 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 13
        , class t_TAIL_13 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 14
        , class t_TAIL_14 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 15
        , class t_TAIL_15 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 16
        , class t_TAIL_16 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 17
        , class t_TAIL_17 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 17
        , class = BSLS_COMPILERFEATURES_NILT>
struct Variant_UsesBslmaAllocatorAny;
 
 
template <>
struct Variant_UsesBslmaAllocatorAny<BSLSTL_VARIANT_NOT_A_TYPE>
: bsl::false_type {
};
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 0
template <class t_HEAD>
struct Variant_UsesBslmaAllocatorAny<t_HEAD>
: bsl::integral_constant<
      bool,
      BloombergLP::bslma::UsesBslmaAllocator<t_HEAD>::value ||
          BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<
          >::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 1
template <class t_HEAD, class t_TAIL_01>
struct Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01>
: bsl::integral_constant<
      bool,
      BloombergLP::bslma::UsesBslmaAllocator<t_HEAD>::value ||
          BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<
          t_TAIL_01>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
struct Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                             t_TAIL_02>
: bsl::integral_constant<
      bool,
      BloombergLP::bslma::UsesBslmaAllocator<t_HEAD>::value ||
          BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<
          t_TAIL_01,
          t_TAIL_02>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
struct Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                             t_TAIL_02,
                                             t_TAIL_03>
: bsl::integral_constant<
      bool,
      BloombergLP::bslma::UsesBslmaAllocator<t_HEAD>::value ||
          BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<
          t_TAIL_01,
          t_TAIL_02,
          t_TAIL_03>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
struct Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                             t_TAIL_02,
                                             t_TAIL_03,
                                             t_TAIL_04>
: bsl::integral_constant<
      bool,
      BloombergLP::bslma::UsesBslmaAllocator<t_HEAD>::value ||
          BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<
          t_TAIL_01,
          t_TAIL_02,
          t_TAIL_03,
          t_TAIL_04>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
struct Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                             t_TAIL_02,
                                             t_TAIL_03,
                                             t_TAIL_04,
                                             t_TAIL_05>
: bsl::integral_constant<
      bool,
      BloombergLP::bslma::UsesBslmaAllocator<t_HEAD>::value ||
          BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<
          t_TAIL_01,
          t_TAIL_02,
          t_TAIL_03,
          t_TAIL_04,
          t_TAIL_05>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
struct Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                             t_TAIL_02,
                                             t_TAIL_03,
                                             t_TAIL_04,
                                             t_TAIL_05,
                                             t_TAIL_06>
: bsl::integral_constant<
      bool,
      BloombergLP::bslma::UsesBslmaAllocator<t_HEAD>::value ||
          BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<
          t_TAIL_01,
          t_TAIL_02,
          t_TAIL_03,
          t_TAIL_04,
          t_TAIL_05,
          t_TAIL_06>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
struct Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                             t_TAIL_02,
                                             t_TAIL_03,
                                             t_TAIL_04,
                                             t_TAIL_05,
                                             t_TAIL_06,
                                             t_TAIL_07>
: bsl::integral_constant<
      bool,
      BloombergLP::bslma::UsesBslmaAllocator<t_HEAD>::value ||
          BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<
          t_TAIL_01,
          t_TAIL_02,
          t_TAIL_03,
          t_TAIL_04,
          t_TAIL_05,
          t_TAIL_06,
          t_TAIL_07>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
struct Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                             t_TAIL_02,
                                             t_TAIL_03,
                                             t_TAIL_04,
                                             t_TAIL_05,
                                             t_TAIL_06,
                                             t_TAIL_07,
                                             t_TAIL_08>
: bsl::integral_constant<
      bool,
      BloombergLP::bslma::UsesBslmaAllocator<t_HEAD>::value ||
          BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<
          t_TAIL_01,
          t_TAIL_02,
          t_TAIL_03,
          t_TAIL_04,
          t_TAIL_05,
          t_TAIL_06,
          t_TAIL_07,
          t_TAIL_08>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
struct Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                             t_TAIL_02,
                                             t_TAIL_03,
                                             t_TAIL_04,
                                             t_TAIL_05,
                                             t_TAIL_06,
                                             t_TAIL_07,
                                             t_TAIL_08,
                                             t_TAIL_09>
: bsl::integral_constant<
      bool,
      BloombergLP::bslma::UsesBslmaAllocator<t_HEAD>::value ||
          BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<
          t_TAIL_01,
          t_TAIL_02,
          t_TAIL_03,
          t_TAIL_04,
          t_TAIL_05,
          t_TAIL_06,
          t_TAIL_07,
          t_TAIL_08,
          t_TAIL_09>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
struct Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                             t_TAIL_02,
                                             t_TAIL_03,
                                             t_TAIL_04,
                                             t_TAIL_05,
                                             t_TAIL_06,
                                             t_TAIL_07,
                                             t_TAIL_08,
                                             t_TAIL_09,
                                             t_TAIL_10>
: bsl::integral_constant<
      bool,
      BloombergLP::bslma::UsesBslmaAllocator<t_HEAD>::value ||
          BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<
          t_TAIL_01,
          t_TAIL_02,
          t_TAIL_03,
          t_TAIL_04,
          t_TAIL_05,
          t_TAIL_06,
          t_TAIL_07,
          t_TAIL_08,
          t_TAIL_09,
          t_TAIL_10>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
struct Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                             t_TAIL_02,
                                             t_TAIL_03,
                                             t_TAIL_04,
                                             t_TAIL_05,
                                             t_TAIL_06,
                                             t_TAIL_07,
                                             t_TAIL_08,
                                             t_TAIL_09,
                                             t_TAIL_10,
                                             t_TAIL_11>
: bsl::integral_constant<
      bool,
      BloombergLP::bslma::UsesBslmaAllocator<t_HEAD>::value ||
          BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<
          t_TAIL_01,
          t_TAIL_02,
          t_TAIL_03,
          t_TAIL_04,
          t_TAIL_05,
          t_TAIL_06,
          t_TAIL_07,
          t_TAIL_08,
          t_TAIL_09,
          t_TAIL_10,
          t_TAIL_11>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
struct Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                             t_TAIL_02,
                                             t_TAIL_03,
                                             t_TAIL_04,
                                             t_TAIL_05,
                                             t_TAIL_06,
                                             t_TAIL_07,
                                             t_TAIL_08,
                                             t_TAIL_09,
                                             t_TAIL_10,
                                             t_TAIL_11,
                                             t_TAIL_12>
: bsl::integral_constant<
      bool,
      BloombergLP::bslma::UsesBslmaAllocator<t_HEAD>::value ||
          BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<
          t_TAIL_01,
          t_TAIL_02,
          t_TAIL_03,
          t_TAIL_04,
          t_TAIL_05,
          t_TAIL_06,
          t_TAIL_07,
          t_TAIL_08,
          t_TAIL_09,
          t_TAIL_10,
          t_TAIL_11,
          t_TAIL_12>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
struct Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                             t_TAIL_02,
                                             t_TAIL_03,
                                             t_TAIL_04,
                                             t_TAIL_05,
                                             t_TAIL_06,
                                             t_TAIL_07,
                                             t_TAIL_08,
                                             t_TAIL_09,
                                             t_TAIL_10,
                                             t_TAIL_11,
                                             t_TAIL_12,
                                             t_TAIL_13>
: bsl::integral_constant<
      bool,
      BloombergLP::bslma::UsesBslmaAllocator<t_HEAD>::value ||
          BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<
          t_TAIL_01,
          t_TAIL_02,
          t_TAIL_03,
          t_TAIL_04,
          t_TAIL_05,
          t_TAIL_06,
          t_TAIL_07,
          t_TAIL_08,
          t_TAIL_09,
          t_TAIL_10,
          t_TAIL_11,
          t_TAIL_12,
          t_TAIL_13>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
struct Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                             t_TAIL_02,
                                             t_TAIL_03,
                                             t_TAIL_04,
                                             t_TAIL_05,
                                             t_TAIL_06,
                                             t_TAIL_07,
                                             t_TAIL_08,
                                             t_TAIL_09,
                                             t_TAIL_10,
                                             t_TAIL_11,
                                             t_TAIL_12,
                                             t_TAIL_13,
                                             t_TAIL_14>
: bsl::integral_constant<
      bool,
      BloombergLP::bslma::UsesBslmaAllocator<t_HEAD>::value ||
          BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<
          t_TAIL_01,
          t_TAIL_02,
          t_TAIL_03,
          t_TAIL_04,
          t_TAIL_05,
          t_TAIL_06,
          t_TAIL_07,
          t_TAIL_08,
          t_TAIL_09,
          t_TAIL_10,
          t_TAIL_11,
          t_TAIL_12,
          t_TAIL_13,
          t_TAIL_14>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
struct Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                             t_TAIL_02,
                                             t_TAIL_03,
                                             t_TAIL_04,
                                             t_TAIL_05,
                                             t_TAIL_06,
                                             t_TAIL_07,
                                             t_TAIL_08,
                                             t_TAIL_09,
                                             t_TAIL_10,
                                             t_TAIL_11,
                                             t_TAIL_12,
                                             t_TAIL_13,
                                             t_TAIL_14,
                                             t_TAIL_15>
: bsl::integral_constant<
      bool,
      BloombergLP::bslma::UsesBslmaAllocator<t_HEAD>::value ||
          BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<
          t_TAIL_01,
          t_TAIL_02,
          t_TAIL_03,
          t_TAIL_04,
          t_TAIL_05,
          t_TAIL_06,
          t_TAIL_07,
          t_TAIL_08,
          t_TAIL_09,
          t_TAIL_10,
          t_TAIL_11,
          t_TAIL_12,
          t_TAIL_13,
          t_TAIL_14,
          t_TAIL_15>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
struct Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                             t_TAIL_02,
                                             t_TAIL_03,
                                             t_TAIL_04,
                                             t_TAIL_05,
                                             t_TAIL_06,
                                             t_TAIL_07,
                                             t_TAIL_08,
                                             t_TAIL_09,
                                             t_TAIL_10,
                                             t_TAIL_11,
                                             t_TAIL_12,
                                             t_TAIL_13,
                                             t_TAIL_14,
                                             t_TAIL_15,
                                             t_TAIL_16>
: bsl::integral_constant<
      bool,
      BloombergLP::bslma::UsesBslmaAllocator<t_HEAD>::value ||
          BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<
          t_TAIL_01,
          t_TAIL_02,
          t_TAIL_03,
          t_TAIL_04,
          t_TAIL_05,
          t_TAIL_06,
          t_TAIL_07,
          t_TAIL_08,
          t_TAIL_09,
          t_TAIL_10,
          t_TAIL_11,
          t_TAIL_12,
          t_TAIL_13,
          t_TAIL_14,
          t_TAIL_15,
          t_TAIL_16>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
struct Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                             t_TAIL_02,
                                             t_TAIL_03,
                                             t_TAIL_04,
                                             t_TAIL_05,
                                             t_TAIL_06,
                                             t_TAIL_07,
                                             t_TAIL_08,
                                             t_TAIL_09,
                                             t_TAIL_10,
                                             t_TAIL_11,
                                             t_TAIL_12,
                                             t_TAIL_13,
                                             t_TAIL_14,
                                             t_TAIL_15,
                                             t_TAIL_16,
                                             t_TAIL_17>
: bsl::integral_constant<
      bool,
      BloombergLP::bslma::UsesBslmaAllocator<t_HEAD>::value ||
          BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<
          t_TAIL_01,
          t_TAIL_02,
          t_TAIL_03,
          t_TAIL_04,
          t_TAIL_05,
          t_TAIL_06,
          t_TAIL_07,
          t_TAIL_08,
          t_TAIL_09,
          t_TAIL_10,
          t_TAIL_11,
          t_TAIL_12,
          t_TAIL_13,
          t_TAIL_14,
          t_TAIL_15,
          t_TAIL_16,
          t_TAIL_17>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
struct Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                             t_TAIL_02,
                                             t_TAIL_03,
                                             t_TAIL_04,
                                             t_TAIL_05,
                                             t_TAIL_06,
                                             t_TAIL_07,
                                             t_TAIL_08,
                                             t_TAIL_09,
                                             t_TAIL_10,
                                             t_TAIL_11,
                                             t_TAIL_12,
                                             t_TAIL_13,
                                             t_TAIL_14,
                                             t_TAIL_15,
                                             t_TAIL_16,
                                             t_TAIL_17,
                                             t_TAIL_18>
: bsl::integral_constant<
      bool,
      BloombergLP::bslma::UsesBslmaAllocator<t_HEAD>::value ||
          BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<
          t_TAIL_01,
          t_TAIL_02,
          t_TAIL_03,
          t_TAIL_04,
          t_TAIL_05,
          t_TAIL_06,
          t_TAIL_07,
          t_TAIL_08,
          t_TAIL_09,
          t_TAIL_10,
          t_TAIL_11,
          t_TAIL_12,
          t_TAIL_13,
          t_TAIL_14,
          t_TAIL_15,
          t_TAIL_16,
          t_TAIL_17,
          t_TAIL_18>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 18
 
 
template <class t_HEAD = BSLSTL_VARIANT_NOT_A_TYPE
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 0
        , class t_TAIL_0 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 1
        , class t_TAIL_1 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 2
        , class t_TAIL_2 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 3
        , class t_TAIL_3 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 4
        , class t_TAIL_4 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 5
        , class t_TAIL_5 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 6
        , class t_TAIL_6 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 7
        , class t_TAIL_7 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 8
        , class t_TAIL_8 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 9
        , class t_TAIL_9 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 10
        , class t_TAIL_10 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 11
        , class t_TAIL_11 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 12
        , class t_TAIL_12 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 13
        , class t_TAIL_13 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 14
        , class t_TAIL_14 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 15
        , class t_TAIL_15 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 16
        , class t_TAIL_16 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 17
        , class t_TAIL_17 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 17
        , class = BSLS_COMPILERFEATURES_NILT>
struct Variant_IsBitwiseMoveableAll;
 
 
template <>
struct Variant_IsBitwiseMoveableAll<BSLSTL_VARIANT_NOT_A_TYPE>
: bsl::true_type {
};
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 0
template <class t_HEAD>
struct Variant_IsBitwiseMoveableAll<t_HEAD>
: bsl::integral_constant<
      bool,
      BloombergLP::bslmf::IsBitwiseMoveable<t_HEAD>::value &&
          Variant_IsBitwiseMoveableAll<>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 1
template <class t_HEAD, class t_TAIL_01>
struct Variant_IsBitwiseMoveableAll<t_HEAD, t_TAIL_01>
: bsl::integral_constant<
      bool,
      BloombergLP::bslmf::IsBitwiseMoveable<t_HEAD>::value &&
          Variant_IsBitwiseMoveableAll<t_TAIL_01>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
struct Variant_IsBitwiseMoveableAll<t_HEAD, t_TAIL_01,
                                            t_TAIL_02>
: bsl::integral_constant<
      bool,
      BloombergLP::bslmf::IsBitwiseMoveable<t_HEAD>::value &&
          Variant_IsBitwiseMoveableAll<t_TAIL_01,
                                       t_TAIL_02>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
struct Variant_IsBitwiseMoveableAll<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03>
: bsl::integral_constant<
      bool,
      BloombergLP::bslmf::IsBitwiseMoveable<t_HEAD>::value &&
          Variant_IsBitwiseMoveableAll<t_TAIL_01,
                                       t_TAIL_02,
                                       t_TAIL_03>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
struct Variant_IsBitwiseMoveableAll<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04>
: bsl::integral_constant<
      bool,
      BloombergLP::bslmf::IsBitwiseMoveable<t_HEAD>::value &&
          Variant_IsBitwiseMoveableAll<t_TAIL_01,
                                       t_TAIL_02,
                                       t_TAIL_03,
                                       t_TAIL_04>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
struct Variant_IsBitwiseMoveableAll<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05>
: bsl::integral_constant<
      bool,
      BloombergLP::bslmf::IsBitwiseMoveable<t_HEAD>::value &&
          Variant_IsBitwiseMoveableAll<t_TAIL_01,
                                       t_TAIL_02,
                                       t_TAIL_03,
                                       t_TAIL_04,
                                       t_TAIL_05>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
struct Variant_IsBitwiseMoveableAll<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06>
: bsl::integral_constant<
      bool,
      BloombergLP::bslmf::IsBitwiseMoveable<t_HEAD>::value &&
          Variant_IsBitwiseMoveableAll<t_TAIL_01,
                                       t_TAIL_02,
                                       t_TAIL_03,
                                       t_TAIL_04,
                                       t_TAIL_05,
                                       t_TAIL_06>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
struct Variant_IsBitwiseMoveableAll<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07>
: bsl::integral_constant<
      bool,
      BloombergLP::bslmf::IsBitwiseMoveable<t_HEAD>::value &&
          Variant_IsBitwiseMoveableAll<t_TAIL_01,
                                       t_TAIL_02,
                                       t_TAIL_03,
                                       t_TAIL_04,
                                       t_TAIL_05,
                                       t_TAIL_06,
                                       t_TAIL_07>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
struct Variant_IsBitwiseMoveableAll<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08>
: bsl::integral_constant<
      bool,
      BloombergLP::bslmf::IsBitwiseMoveable<t_HEAD>::value &&
          Variant_IsBitwiseMoveableAll<t_TAIL_01,
                                       t_TAIL_02,
                                       t_TAIL_03,
                                       t_TAIL_04,
                                       t_TAIL_05,
                                       t_TAIL_06,
                                       t_TAIL_07,
                                       t_TAIL_08>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
struct Variant_IsBitwiseMoveableAll<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09>
: bsl::integral_constant<
      bool,
      BloombergLP::bslmf::IsBitwiseMoveable<t_HEAD>::value &&
          Variant_IsBitwiseMoveableAll<t_TAIL_01,
                                       t_TAIL_02,
                                       t_TAIL_03,
                                       t_TAIL_04,
                                       t_TAIL_05,
                                       t_TAIL_06,
                                       t_TAIL_07,
                                       t_TAIL_08,
                                       t_TAIL_09>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
struct Variant_IsBitwiseMoveableAll<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10>
: bsl::integral_constant<
      bool,
      BloombergLP::bslmf::IsBitwiseMoveable<t_HEAD>::value &&
          Variant_IsBitwiseMoveableAll<t_TAIL_01,
                                       t_TAIL_02,
                                       t_TAIL_03,
                                       t_TAIL_04,
                                       t_TAIL_05,
                                       t_TAIL_06,
                                       t_TAIL_07,
                                       t_TAIL_08,
                                       t_TAIL_09,
                                       t_TAIL_10>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
struct Variant_IsBitwiseMoveableAll<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11>
: bsl::integral_constant<
      bool,
      BloombergLP::bslmf::IsBitwiseMoveable<t_HEAD>::value &&
          Variant_IsBitwiseMoveableAll<t_TAIL_01,
                                       t_TAIL_02,
                                       t_TAIL_03,
                                       t_TAIL_04,
                                       t_TAIL_05,
                                       t_TAIL_06,
                                       t_TAIL_07,
                                       t_TAIL_08,
                                       t_TAIL_09,
                                       t_TAIL_10,
                                       t_TAIL_11>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
struct Variant_IsBitwiseMoveableAll<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12>
: bsl::integral_constant<
      bool,
      BloombergLP::bslmf::IsBitwiseMoveable<t_HEAD>::value &&
          Variant_IsBitwiseMoveableAll<t_TAIL_01,
                                       t_TAIL_02,
                                       t_TAIL_03,
                                       t_TAIL_04,
                                       t_TAIL_05,
                                       t_TAIL_06,
                                       t_TAIL_07,
                                       t_TAIL_08,
                                       t_TAIL_09,
                                       t_TAIL_10,
                                       t_TAIL_11,
                                       t_TAIL_12>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
struct Variant_IsBitwiseMoveableAll<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13>
: bsl::integral_constant<
      bool,
      BloombergLP::bslmf::IsBitwiseMoveable<t_HEAD>::value &&
          Variant_IsBitwiseMoveableAll<t_TAIL_01,
                                       t_TAIL_02,
                                       t_TAIL_03,
                                       t_TAIL_04,
                                       t_TAIL_05,
                                       t_TAIL_06,
                                       t_TAIL_07,
                                       t_TAIL_08,
                                       t_TAIL_09,
                                       t_TAIL_10,
                                       t_TAIL_11,
                                       t_TAIL_12,
                                       t_TAIL_13>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
struct Variant_IsBitwiseMoveableAll<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14>
: bsl::integral_constant<
      bool,
      BloombergLP::bslmf::IsBitwiseMoveable<t_HEAD>::value &&
          Variant_IsBitwiseMoveableAll<t_TAIL_01,
                                       t_TAIL_02,
                                       t_TAIL_03,
                                       t_TAIL_04,
                                       t_TAIL_05,
                                       t_TAIL_06,
                                       t_TAIL_07,
                                       t_TAIL_08,
                                       t_TAIL_09,
                                       t_TAIL_10,
                                       t_TAIL_11,
                                       t_TAIL_12,
                                       t_TAIL_13,
                                       t_TAIL_14>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
struct Variant_IsBitwiseMoveableAll<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15>
: bsl::integral_constant<
      bool,
      BloombergLP::bslmf::IsBitwiseMoveable<t_HEAD>::value &&
          Variant_IsBitwiseMoveableAll<t_TAIL_01,
                                       t_TAIL_02,
                                       t_TAIL_03,
                                       t_TAIL_04,
                                       t_TAIL_05,
                                       t_TAIL_06,
                                       t_TAIL_07,
                                       t_TAIL_08,
                                       t_TAIL_09,
                                       t_TAIL_10,
                                       t_TAIL_11,
                                       t_TAIL_12,
                                       t_TAIL_13,
                                       t_TAIL_14,
                                       t_TAIL_15>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
struct Variant_IsBitwiseMoveableAll<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16>
: bsl::integral_constant<
      bool,
      BloombergLP::bslmf::IsBitwiseMoveable<t_HEAD>::value &&
          Variant_IsBitwiseMoveableAll<t_TAIL_01,
                                       t_TAIL_02,
                                       t_TAIL_03,
                                       t_TAIL_04,
                                       t_TAIL_05,
                                       t_TAIL_06,
                                       t_TAIL_07,
                                       t_TAIL_08,
                                       t_TAIL_09,
                                       t_TAIL_10,
                                       t_TAIL_11,
                                       t_TAIL_12,
                                       t_TAIL_13,
                                       t_TAIL_14,
                                       t_TAIL_15,
                                       t_TAIL_16>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
struct Variant_IsBitwiseMoveableAll<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16,
                                            t_TAIL_17>
: bsl::integral_constant<
      bool,
      BloombergLP::bslmf::IsBitwiseMoveable<t_HEAD>::value &&
          Variant_IsBitwiseMoveableAll<t_TAIL_01,
                                       t_TAIL_02,
                                       t_TAIL_03,
                                       t_TAIL_04,
                                       t_TAIL_05,
                                       t_TAIL_06,
                                       t_TAIL_07,
                                       t_TAIL_08,
                                       t_TAIL_09,
                                       t_TAIL_10,
                                       t_TAIL_11,
                                       t_TAIL_12,
                                       t_TAIL_13,
                                       t_TAIL_14,
                                       t_TAIL_15,
                                       t_TAIL_16,
                                       t_TAIL_17>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
struct Variant_IsBitwiseMoveableAll<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16,
                                            t_TAIL_17,
                                            t_TAIL_18>
: bsl::integral_constant<
      bool,
      BloombergLP::bslmf::IsBitwiseMoveable<t_HEAD>::value &&
          Variant_IsBitwiseMoveableAll<t_TAIL_01,
                                       t_TAIL_02,
                                       t_TAIL_03,
                                       t_TAIL_04,
                                       t_TAIL_05,
                                       t_TAIL_06,
                                       t_TAIL_07,
                                       t_TAIL_08,
                                       t_TAIL_09,
                                       t_TAIL_10,
                                       t_TAIL_11,
                                       t_TAIL_12,
                                       t_TAIL_13,
                                       t_TAIL_14,
                                       t_TAIL_15,
                                       t_TAIL_16,
                                       t_TAIL_17,
                                       t_TAIL_18>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 18
 
 
template <class t_TYPE>
struct Variant_IsTag : bsl::false_type {
};
 
template <>
struct Variant_IsTag<bsl::allocator_arg_t> : bsl::true_type {
};
 
template <class t_TYPE>
struct Variant_IsTag<bsl::in_place_type_t<t_TYPE> > : bsl::true_type {
};
 
template <size_t t_INDEX>
struct Variant_IsTag<bsl::in_place_index_t<t_INDEX> > : bsl::true_type {
};
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
template <class t_TO, class t_FROM>
struct Variant_IsConstructible : std::is_constructible<t_TO, t_FROM> {
};
 
template <class t_LHS, class t_RHS>
struct Variant_IsAssignable : std::is_assignable<t_LHS, t_RHS> {
};
#else
template <class t_TO, class t_FROM>
struct Variant_IsConstructible : bsl::true_type {
};
 
template <class t_LHS, class t_RHS>
struct Variant_IsAssignable : bsl::true_type {
};
#endif
 
#define BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(VARIANT, TYPE)               \
    typename bsl::enable_if<                                                  \
        BloombergLP::bslstl::Variant_ConstructsFromType<VARIANT,              \
                                                        TYPE>::value,         \
        BloombergLP::bslstl::Variant_NoSuchType>::type
 
#define BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(VARIANT, TYPE)              \
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(                                 \
                        VARIANT,                                              \
                        TYPE) = BloombergLP::bslstl::Variant_NoSuchType(0)
 
#define BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM_STD(STD_VARIANT)             \
    bsl::enable_if_t<                                                         \
        BloombergLP::bslstl::variant_constructsFromStd<variant, STD_VARIANT>, \
        BloombergLP::bslstl::Variant_NoSuchType>
 
#define BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(STD_VARIANT)            \
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM_STD(STD_VARIANT)                 \
        = BloombergLP::bslstl::Variant_NoSuchType(0)
 
#define BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(TYPE)                        \
    typename bsl::enable_if<                                                  \
        BloombergLP::bslstl::Variant_HasUniqueType<TYPE, variant>::value,     \
        BloombergLP::bslstl::Variant_NoSuchType>::type
 
#define BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(TYPE)                       \
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(                                 \
                           TYPE) = BloombergLP::bslstl::Variant_NoSuchType(0)
 
#define BSLSTL_VARIANT_HAS_UNIQUE_TYPE(TYPE)                                  \
    BloombergLP::bslstl::                                                     \
        Variant_HasUniqueType<TYPE, variant<t_HEAD, t_TAIL...> >::value
 
#define BSLSTL_VARIANT_TYPE_AT_INDEX(INDEX)                                   \
    typename bsl::variant_alternative<INDEX,                                  \
                                      bsl::variant<t_HEAD, t_TAIL...> >::type
 
#define BSLSTL_VARIANT_INDEX_OF(TYPE, VARIANT)                                \
    BloombergLP::bslstl::Variant_TypeToIndex<TYPE, VARIANT>::value
 
#define BSLSTL_VARIANT_CONVERT_INDEX_OF(TYPE, VARIANT)                        \
    BloombergLP::bslstl::Variant_ConvertIndex<TYPE, VARIANT>::value
 
#define BSLSTL_VARIANT_CONVERT_TYPE_OF(TYPE, VARIANT)                         \
    typename bsl::variant_alternative<BSLSTL_VARIANT_CONVERT_INDEX_OF(        \
                                          TYPE, VARIANT),                     \
                                      VARIANT>::type
 
#define BSLSTL_VARIANT_VISITID(RET, VISITOR, VAROBJ)                          \
    BloombergLP::bslstl::Variant_ImpUtil::visitId<RET>(VISITOR, VAROBJ);
 
template <size_t t_INDEX,
          class t_TYPE,
          class t_HEAD = BSLSTL_VARIANT_NOT_A_TYPE
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 0
        , class t_TAIL_0 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 1
        , class t_TAIL_1 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 2
        , class t_TAIL_2 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 3
        , class t_TAIL_3 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 4
        , class t_TAIL_4 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 5
        , class t_TAIL_5 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 6
        , class t_TAIL_6 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 7
        , class t_TAIL_7 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 8
        , class t_TAIL_8 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 9
        , class t_TAIL_9 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 10
        , class t_TAIL_10 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 11
        , class t_TAIL_11 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 12
        , class t_TAIL_12 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 13
        , class t_TAIL_13 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 14
        , class t_TAIL_14 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 15
        , class t_TAIL_15 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 16
        , class t_TAIL_16 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 17
        , class t_TAIL_17 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 17
        , class = BSLS_COMPILERFEATURES_NILT>
struct Variant_TypeToIndexImpl;
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 0
template <size_t t_INDEX, class t_TYPE, class t_HEAD>
struct Variant_TypeToIndexImpl<t_INDEX, t_TYPE, t_HEAD>
: bsl::conditional<
      bsl::is_same<t_TYPE, t_HEAD>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_TypeToIndexImpl<t_INDEX + 1, t_TYPE> >::type {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 1
template <size_t t_INDEX, class t_TYPE, class t_HEAD, class t_TAIL_01>
struct Variant_TypeToIndexImpl<t_INDEX, t_TYPE, t_HEAD, t_TAIL_01>
: bsl::conditional<
      bsl::is_same<t_TYPE, t_HEAD>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_TypeToIndexImpl<t_INDEX + 1, t_TYPE, t_TAIL_01> >::type {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 2
template <size_t t_INDEX, class t_TYPE, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02>
struct Variant_TypeToIndexImpl<t_INDEX, t_TYPE, t_HEAD, t_TAIL_01,
                                                        t_TAIL_02>
: bsl::conditional<
      bsl::is_same<t_TYPE, t_HEAD>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_TypeToIndexImpl<t_INDEX + 1, t_TYPE, t_TAIL_01,
                                                   t_TAIL_02> >::type {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 3
template <size_t t_INDEX, class t_TYPE, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03>
struct Variant_TypeToIndexImpl<t_INDEX, t_TYPE, t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03>
: bsl::conditional<
      bsl::is_same<t_TYPE, t_HEAD>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_TypeToIndexImpl<t_INDEX + 1, t_TYPE, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03> >::type {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 4
template <size_t t_INDEX, class t_TYPE, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04>
struct Variant_TypeToIndexImpl<t_INDEX, t_TYPE, t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04>
: bsl::conditional<
      bsl::is_same<t_TYPE, t_HEAD>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_TypeToIndexImpl<t_INDEX + 1, t_TYPE, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04> >::type {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 5
template <size_t t_INDEX, class t_TYPE, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05>
struct Variant_TypeToIndexImpl<t_INDEX, t_TYPE, t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05>
: bsl::conditional<
      bsl::is_same<t_TYPE, t_HEAD>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_TypeToIndexImpl<t_INDEX + 1, t_TYPE, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05> >::type {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 6
template <size_t t_INDEX, class t_TYPE, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06>
struct Variant_TypeToIndexImpl<t_INDEX, t_TYPE, t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06>
: bsl::conditional<
      bsl::is_same<t_TYPE, t_HEAD>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_TypeToIndexImpl<t_INDEX + 1, t_TYPE, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06> >::type {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 7
template <size_t t_INDEX, class t_TYPE, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07>
struct Variant_TypeToIndexImpl<t_INDEX, t_TYPE, t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07>
: bsl::conditional<
      bsl::is_same<t_TYPE, t_HEAD>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_TypeToIndexImpl<t_INDEX + 1, t_TYPE, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07> >::type {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 8
template <size_t t_INDEX, class t_TYPE, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08>
struct Variant_TypeToIndexImpl<t_INDEX, t_TYPE, t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08>
: bsl::conditional<
      bsl::is_same<t_TYPE, t_HEAD>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_TypeToIndexImpl<t_INDEX + 1, t_TYPE, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08> >::type {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 9
template <size_t t_INDEX, class t_TYPE, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09>
struct Variant_TypeToIndexImpl<t_INDEX, t_TYPE, t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09>
: bsl::conditional<
      bsl::is_same<t_TYPE, t_HEAD>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_TypeToIndexImpl<t_INDEX + 1, t_TYPE, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09> >::type {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 10
template <size_t t_INDEX, class t_TYPE, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09,
                                                      class t_TAIL_10>
struct Variant_TypeToIndexImpl<t_INDEX, t_TYPE, t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09,
                                                        t_TAIL_10>
: bsl::conditional<
      bsl::is_same<t_TYPE, t_HEAD>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_TypeToIndexImpl<t_INDEX + 1, t_TYPE, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10> >::type {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 11
template <size_t t_INDEX, class t_TYPE, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09,
                                                      class t_TAIL_10,
                                                      class t_TAIL_11>
struct Variant_TypeToIndexImpl<t_INDEX, t_TYPE, t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09,
                                                        t_TAIL_10,
                                                        t_TAIL_11>
: bsl::conditional<
      bsl::is_same<t_TYPE, t_HEAD>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_TypeToIndexImpl<t_INDEX + 1, t_TYPE, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11> >::type {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 12
template <size_t t_INDEX, class t_TYPE, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09,
                                                      class t_TAIL_10,
                                                      class t_TAIL_11,
                                                      class t_TAIL_12>
struct Variant_TypeToIndexImpl<t_INDEX, t_TYPE, t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09,
                                                        t_TAIL_10,
                                                        t_TAIL_11,
                                                        t_TAIL_12>
: bsl::conditional<
      bsl::is_same<t_TYPE, t_HEAD>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_TypeToIndexImpl<t_INDEX + 1, t_TYPE, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11,
                                                   t_TAIL_12> >::type {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 13
template <size_t t_INDEX, class t_TYPE, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09,
                                                      class t_TAIL_10,
                                                      class t_TAIL_11,
                                                      class t_TAIL_12,
                                                      class t_TAIL_13>
struct Variant_TypeToIndexImpl<t_INDEX, t_TYPE, t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09,
                                                        t_TAIL_10,
                                                        t_TAIL_11,
                                                        t_TAIL_12,
                                                        t_TAIL_13>
: bsl::conditional<
      bsl::is_same<t_TYPE, t_HEAD>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_TypeToIndexImpl<t_INDEX + 1, t_TYPE, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11,
                                                   t_TAIL_12,
                                                   t_TAIL_13> >::type {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 14
template <size_t t_INDEX, class t_TYPE, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09,
                                                      class t_TAIL_10,
                                                      class t_TAIL_11,
                                                      class t_TAIL_12,
                                                      class t_TAIL_13,
                                                      class t_TAIL_14>
struct Variant_TypeToIndexImpl<t_INDEX, t_TYPE, t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09,
                                                        t_TAIL_10,
                                                        t_TAIL_11,
                                                        t_TAIL_12,
                                                        t_TAIL_13,
                                                        t_TAIL_14>
: bsl::conditional<
      bsl::is_same<t_TYPE, t_HEAD>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_TypeToIndexImpl<t_INDEX + 1, t_TYPE, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11,
                                                   t_TAIL_12,
                                                   t_TAIL_13,
                                                   t_TAIL_14> >::type {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 15
template <size_t t_INDEX, class t_TYPE, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09,
                                                      class t_TAIL_10,
                                                      class t_TAIL_11,
                                                      class t_TAIL_12,
                                                      class t_TAIL_13,
                                                      class t_TAIL_14,
                                                      class t_TAIL_15>
struct Variant_TypeToIndexImpl<t_INDEX, t_TYPE, t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09,
                                                        t_TAIL_10,
                                                        t_TAIL_11,
                                                        t_TAIL_12,
                                                        t_TAIL_13,
                                                        t_TAIL_14,
                                                        t_TAIL_15>
: bsl::conditional<
      bsl::is_same<t_TYPE, t_HEAD>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_TypeToIndexImpl<t_INDEX + 1, t_TYPE, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11,
                                                   t_TAIL_12,
                                                   t_TAIL_13,
                                                   t_TAIL_14,
                                                   t_TAIL_15> >::type {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 16
template <size_t t_INDEX, class t_TYPE, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09,
                                                      class t_TAIL_10,
                                                      class t_TAIL_11,
                                                      class t_TAIL_12,
                                                      class t_TAIL_13,
                                                      class t_TAIL_14,
                                                      class t_TAIL_15,
                                                      class t_TAIL_16>
struct Variant_TypeToIndexImpl<t_INDEX, t_TYPE, t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09,
                                                        t_TAIL_10,
                                                        t_TAIL_11,
                                                        t_TAIL_12,
                                                        t_TAIL_13,
                                                        t_TAIL_14,
                                                        t_TAIL_15,
                                                        t_TAIL_16>
: bsl::conditional<
      bsl::is_same<t_TYPE, t_HEAD>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_TypeToIndexImpl<t_INDEX + 1, t_TYPE, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11,
                                                   t_TAIL_12,
                                                   t_TAIL_13,
                                                   t_TAIL_14,
                                                   t_TAIL_15,
                                                   t_TAIL_16> >::type {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 17
template <size_t t_INDEX, class t_TYPE, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09,
                                                      class t_TAIL_10,
                                                      class t_TAIL_11,
                                                      class t_TAIL_12,
                                                      class t_TAIL_13,
                                                      class t_TAIL_14,
                                                      class t_TAIL_15,
                                                      class t_TAIL_16,
                                                      class t_TAIL_17>
struct Variant_TypeToIndexImpl<t_INDEX, t_TYPE, t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09,
                                                        t_TAIL_10,
                                                        t_TAIL_11,
                                                        t_TAIL_12,
                                                        t_TAIL_13,
                                                        t_TAIL_14,
                                                        t_TAIL_15,
                                                        t_TAIL_16,
                                                        t_TAIL_17>
: bsl::conditional<
      bsl::is_same<t_TYPE, t_HEAD>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_TypeToIndexImpl<t_INDEX + 1, t_TYPE, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11,
                                                   t_TAIL_12,
                                                   t_TAIL_13,
                                                   t_TAIL_14,
                                                   t_TAIL_15,
                                                   t_TAIL_16,
                                                   t_TAIL_17> >::type {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 18
template <size_t t_INDEX, class t_TYPE, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09,
                                                      class t_TAIL_10,
                                                      class t_TAIL_11,
                                                      class t_TAIL_12,
                                                      class t_TAIL_13,
                                                      class t_TAIL_14,
                                                      class t_TAIL_15,
                                                      class t_TAIL_16,
                                                      class t_TAIL_17,
                                                      class t_TAIL_18>
struct Variant_TypeToIndexImpl<t_INDEX, t_TYPE, t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09,
                                                        t_TAIL_10,
                                                        t_TAIL_11,
                                                        t_TAIL_12,
                                                        t_TAIL_13,
                                                        t_TAIL_14,
                                                        t_TAIL_15,
                                                        t_TAIL_16,
                                                        t_TAIL_17,
                                                        t_TAIL_18>
: bsl::conditional<
      bsl::is_same<t_TYPE, t_HEAD>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_TypeToIndexImpl<t_INDEX + 1, t_TYPE, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11,
                                                   t_TAIL_12,
                                                   t_TAIL_13,
                                                   t_TAIL_14,
                                                   t_TAIL_15,
                                                   t_TAIL_16,
                                                   t_TAIL_17,
                                                   t_TAIL_18> >::type {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 18
 
 
template <size_t t_INDEX, class t_TYPE>
struct Variant_TypeToIndexImpl<t_INDEX, t_TYPE, BSLSTL_VARIANT_NOT_A_TYPE>
: bsl::integral_constant<size_t, bsl::variant_npos> {
};
 
template <class t_TYPE, class t_VARIANT>
struct Variant_TypeToIndex;
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 0
template <class t_TYPE, class t_HEAD>
struct Variant_TypeToIndex<t_TYPE, bsl::variant<t_HEAD> >
: Variant_TypeToIndexImpl<0, t_TYPE, t_HEAD> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 1
template <class t_TYPE, class t_HEAD, class t_TAIL_01>
struct Variant_TypeToIndex<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01> >
: Variant_TypeToIndexImpl<0, t_TYPE, t_HEAD, t_TAIL_01> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 2
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02>
struct Variant_TypeToIndex<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02> >
: Variant_TypeToIndexImpl<0, t_TYPE, t_HEAD, t_TAIL_01,
                                             t_TAIL_02> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 3
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03>
struct Variant_TypeToIndex<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03> >
: Variant_TypeToIndexImpl<0, t_TYPE, t_HEAD, t_TAIL_01,
                                             t_TAIL_02,
                                             t_TAIL_03> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 4
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04>
struct Variant_TypeToIndex<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04> >
: Variant_TypeToIndexImpl<0, t_TYPE, t_HEAD, t_TAIL_01,
                                             t_TAIL_02,
                                             t_TAIL_03,
                                             t_TAIL_04> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 5
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05>
struct Variant_TypeToIndex<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05> >
: Variant_TypeToIndexImpl<0, t_TYPE, t_HEAD, t_TAIL_01,
                                             t_TAIL_02,
                                             t_TAIL_03,
                                             t_TAIL_04,
                                             t_TAIL_05> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 6
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06>
struct Variant_TypeToIndex<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06> >
: Variant_TypeToIndexImpl<0, t_TYPE, t_HEAD, t_TAIL_01,
                                             t_TAIL_02,
                                             t_TAIL_03,
                                             t_TAIL_04,
                                             t_TAIL_05,
                                             t_TAIL_06> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 7
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07>
struct Variant_TypeToIndex<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07> >
: Variant_TypeToIndexImpl<0, t_TYPE, t_HEAD, t_TAIL_01,
                                             t_TAIL_02,
                                             t_TAIL_03,
                                             t_TAIL_04,
                                             t_TAIL_05,
                                             t_TAIL_06,
                                             t_TAIL_07> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 8
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08>
struct Variant_TypeToIndex<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08> >
: Variant_TypeToIndexImpl<0, t_TYPE, t_HEAD, t_TAIL_01,
                                             t_TAIL_02,
                                             t_TAIL_03,
                                             t_TAIL_04,
                                             t_TAIL_05,
                                             t_TAIL_06,
                                             t_TAIL_07,
                                             t_TAIL_08> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 9
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09>
struct Variant_TypeToIndex<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09> >
: Variant_TypeToIndexImpl<0, t_TYPE, t_HEAD, t_TAIL_01,
                                             t_TAIL_02,
                                             t_TAIL_03,
                                             t_TAIL_04,
                                             t_TAIL_05,
                                             t_TAIL_06,
                                             t_TAIL_07,
                                             t_TAIL_08,
                                             t_TAIL_09> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 10
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10>
struct Variant_TypeToIndex<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09,
                                                        t_TAIL_10> >
: Variant_TypeToIndexImpl<0, t_TYPE, t_HEAD, t_TAIL_01,
                                             t_TAIL_02,
                                             t_TAIL_03,
                                             t_TAIL_04,
                                             t_TAIL_05,
                                             t_TAIL_06,
                                             t_TAIL_07,
                                             t_TAIL_08,
                                             t_TAIL_09,
                                             t_TAIL_10> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 11
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11>
struct Variant_TypeToIndex<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09,
                                                        t_TAIL_10,
                                                        t_TAIL_11> >
: Variant_TypeToIndexImpl<0, t_TYPE, t_HEAD, t_TAIL_01,
                                             t_TAIL_02,
                                             t_TAIL_03,
                                             t_TAIL_04,
                                             t_TAIL_05,
                                             t_TAIL_06,
                                             t_TAIL_07,
                                             t_TAIL_08,
                                             t_TAIL_09,
                                             t_TAIL_10,
                                             t_TAIL_11> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 12
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12>
struct Variant_TypeToIndex<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09,
                                                        t_TAIL_10,
                                                        t_TAIL_11,
                                                        t_TAIL_12> >
: Variant_TypeToIndexImpl<0, t_TYPE, t_HEAD, t_TAIL_01,
                                             t_TAIL_02,
                                             t_TAIL_03,
                                             t_TAIL_04,
                                             t_TAIL_05,
                                             t_TAIL_06,
                                             t_TAIL_07,
                                             t_TAIL_08,
                                             t_TAIL_09,
                                             t_TAIL_10,
                                             t_TAIL_11,
                                             t_TAIL_12> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 13
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13>
struct Variant_TypeToIndex<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09,
                                                        t_TAIL_10,
                                                        t_TAIL_11,
                                                        t_TAIL_12,
                                                        t_TAIL_13> >
: Variant_TypeToIndexImpl<0, t_TYPE, t_HEAD, t_TAIL_01,
                                             t_TAIL_02,
                                             t_TAIL_03,
                                             t_TAIL_04,
                                             t_TAIL_05,
                                             t_TAIL_06,
                                             t_TAIL_07,
                                             t_TAIL_08,
                                             t_TAIL_09,
                                             t_TAIL_10,
                                             t_TAIL_11,
                                             t_TAIL_12,
                                             t_TAIL_13> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 14
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14>
struct Variant_TypeToIndex<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09,
                                                        t_TAIL_10,
                                                        t_TAIL_11,
                                                        t_TAIL_12,
                                                        t_TAIL_13,
                                                        t_TAIL_14> >
: Variant_TypeToIndexImpl<0, t_TYPE, t_HEAD, t_TAIL_01,
                                             t_TAIL_02,
                                             t_TAIL_03,
                                             t_TAIL_04,
                                             t_TAIL_05,
                                             t_TAIL_06,
                                             t_TAIL_07,
                                             t_TAIL_08,
                                             t_TAIL_09,
                                             t_TAIL_10,
                                             t_TAIL_11,
                                             t_TAIL_12,
                                             t_TAIL_13,
                                             t_TAIL_14> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 15
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14,
                                      class t_TAIL_15>
struct Variant_TypeToIndex<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09,
                                                        t_TAIL_10,
                                                        t_TAIL_11,
                                                        t_TAIL_12,
                                                        t_TAIL_13,
                                                        t_TAIL_14,
                                                        t_TAIL_15> >
: Variant_TypeToIndexImpl<0, t_TYPE, t_HEAD, t_TAIL_01,
                                             t_TAIL_02,
                                             t_TAIL_03,
                                             t_TAIL_04,
                                             t_TAIL_05,
                                             t_TAIL_06,
                                             t_TAIL_07,
                                             t_TAIL_08,
                                             t_TAIL_09,
                                             t_TAIL_10,
                                             t_TAIL_11,
                                             t_TAIL_12,
                                             t_TAIL_13,
                                             t_TAIL_14,
                                             t_TAIL_15> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 16
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14,
                                      class t_TAIL_15,
                                      class t_TAIL_16>
struct Variant_TypeToIndex<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09,
                                                        t_TAIL_10,
                                                        t_TAIL_11,
                                                        t_TAIL_12,
                                                        t_TAIL_13,
                                                        t_TAIL_14,
                                                        t_TAIL_15,
                                                        t_TAIL_16> >
: Variant_TypeToIndexImpl<0, t_TYPE, t_HEAD, t_TAIL_01,
                                             t_TAIL_02,
                                             t_TAIL_03,
                                             t_TAIL_04,
                                             t_TAIL_05,
                                             t_TAIL_06,
                                             t_TAIL_07,
                                             t_TAIL_08,
                                             t_TAIL_09,
                                             t_TAIL_10,
                                             t_TAIL_11,
                                             t_TAIL_12,
                                             t_TAIL_13,
                                             t_TAIL_14,
                                             t_TAIL_15,
                                             t_TAIL_16> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 17
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14,
                                      class t_TAIL_15,
                                      class t_TAIL_16,
                                      class t_TAIL_17>
struct Variant_TypeToIndex<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09,
                                                        t_TAIL_10,
                                                        t_TAIL_11,
                                                        t_TAIL_12,
                                                        t_TAIL_13,
                                                        t_TAIL_14,
                                                        t_TAIL_15,
                                                        t_TAIL_16,
                                                        t_TAIL_17> >
: Variant_TypeToIndexImpl<0, t_TYPE, t_HEAD, t_TAIL_01,
                                             t_TAIL_02,
                                             t_TAIL_03,
                                             t_TAIL_04,
                                             t_TAIL_05,
                                             t_TAIL_06,
                                             t_TAIL_07,
                                             t_TAIL_08,
                                             t_TAIL_09,
                                             t_TAIL_10,
                                             t_TAIL_11,
                                             t_TAIL_12,
                                             t_TAIL_13,
                                             t_TAIL_14,
                                             t_TAIL_15,
                                             t_TAIL_16,
                                             t_TAIL_17> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 18
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14,
                                      class t_TAIL_15,
                                      class t_TAIL_16,
                                      class t_TAIL_17,
                                      class t_TAIL_18>
struct Variant_TypeToIndex<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09,
                                                        t_TAIL_10,
                                                        t_TAIL_11,
                                                        t_TAIL_12,
                                                        t_TAIL_13,
                                                        t_TAIL_14,
                                                        t_TAIL_15,
                                                        t_TAIL_16,
                                                        t_TAIL_17,
                                                        t_TAIL_18> >
: Variant_TypeToIndexImpl<0, t_TYPE, t_HEAD, t_TAIL_01,
                                             t_TAIL_02,
                                             t_TAIL_03,
                                             t_TAIL_04,
                                             t_TAIL_05,
                                             t_TAIL_06,
                                             t_TAIL_07,
                                             t_TAIL_08,
                                             t_TAIL_09,
                                             t_TAIL_10,
                                             t_TAIL_11,
                                             t_TAIL_12,
                                             t_TAIL_13,
                                             t_TAIL_14,
                                             t_TAIL_15,
                                             t_TAIL_16,
                                             t_TAIL_17,
                                             t_TAIL_18> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 18
 
 
template <class t_TYPE,
          class t_HEAD = BSLSTL_VARIANT_NOT_A_TYPE
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 0
        , class t_TAIL_0 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 1
        , class t_TAIL_1 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 2
        , class t_TAIL_2 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 3
        , class t_TAIL_3 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 4
        , class t_TAIL_4 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 5
        , class t_TAIL_5 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 6
        , class t_TAIL_6 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 7
        , class t_TAIL_7 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 8
        , class t_TAIL_8 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 9
        , class t_TAIL_9 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 10
        , class t_TAIL_10 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 11
        , class t_TAIL_11 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 12
        , class t_TAIL_12 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 13
        , class t_TAIL_13 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 14
        , class t_TAIL_14 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 15
        , class t_TAIL_15 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 16
        , class t_TAIL_16 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 17
        , class t_TAIL_17 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 17
        , class = BSLS_COMPILERFEATURES_NILT>
struct Variant_CountType;
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 0
template <class t_TYPE, class t_HEAD>
struct Variant_CountType<t_TYPE, t_HEAD>
: bsl::integral_constant<size_t,
                         bsl::is_same<t_TYPE, t_HEAD>::value +
                             Variant_CountType<t_TYPE>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 1
template <class t_TYPE, class t_HEAD, class t_TAIL_01>
struct Variant_CountType<t_TYPE, t_HEAD, t_TAIL_01>
: bsl::integral_constant<size_t,
                         bsl::is_same<t_TYPE, t_HEAD>::value +
                             Variant_CountType<t_TYPE, t_TAIL_01>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 2
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02>
struct Variant_CountType<t_TYPE, t_HEAD, t_TAIL_01,
                                         t_TAIL_02>
: bsl::integral_constant<size_t,
                         bsl::is_same<t_TYPE, t_HEAD>::value +
                             Variant_CountType<t_TYPE, t_TAIL_01,
                                                       t_TAIL_02>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 3
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03>
struct Variant_CountType<t_TYPE, t_HEAD, t_TAIL_01,
                                         t_TAIL_02,
                                         t_TAIL_03>
: bsl::integral_constant<size_t,
                         bsl::is_same<t_TYPE, t_HEAD>::value +
                             Variant_CountType<t_TYPE, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 4
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04>
struct Variant_CountType<t_TYPE, t_HEAD, t_TAIL_01,
                                         t_TAIL_02,
                                         t_TAIL_03,
                                         t_TAIL_04>
: bsl::integral_constant<size_t,
                         bsl::is_same<t_TYPE, t_HEAD>::value +
                             Variant_CountType<t_TYPE, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 5
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05>
struct Variant_CountType<t_TYPE, t_HEAD, t_TAIL_01,
                                         t_TAIL_02,
                                         t_TAIL_03,
                                         t_TAIL_04,
                                         t_TAIL_05>
: bsl::integral_constant<size_t,
                         bsl::is_same<t_TYPE, t_HEAD>::value +
                             Variant_CountType<t_TYPE, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 6
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06>
struct Variant_CountType<t_TYPE, t_HEAD, t_TAIL_01,
                                         t_TAIL_02,
                                         t_TAIL_03,
                                         t_TAIL_04,
                                         t_TAIL_05,
                                         t_TAIL_06>
: bsl::integral_constant<size_t,
                         bsl::is_same<t_TYPE, t_HEAD>::value +
                             Variant_CountType<t_TYPE, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 7
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07>
struct Variant_CountType<t_TYPE, t_HEAD, t_TAIL_01,
                                         t_TAIL_02,
                                         t_TAIL_03,
                                         t_TAIL_04,
                                         t_TAIL_05,
                                         t_TAIL_06,
                                         t_TAIL_07>
: bsl::integral_constant<size_t,
                         bsl::is_same<t_TYPE, t_HEAD>::value +
                             Variant_CountType<t_TYPE, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 8
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08>
struct Variant_CountType<t_TYPE, t_HEAD, t_TAIL_01,
                                         t_TAIL_02,
                                         t_TAIL_03,
                                         t_TAIL_04,
                                         t_TAIL_05,
                                         t_TAIL_06,
                                         t_TAIL_07,
                                         t_TAIL_08>
: bsl::integral_constant<size_t,
                         bsl::is_same<t_TYPE, t_HEAD>::value +
                             Variant_CountType<t_TYPE, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 9
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09>
struct Variant_CountType<t_TYPE, t_HEAD, t_TAIL_01,
                                         t_TAIL_02,
                                         t_TAIL_03,
                                         t_TAIL_04,
                                         t_TAIL_05,
                                         t_TAIL_06,
                                         t_TAIL_07,
                                         t_TAIL_08,
                                         t_TAIL_09>
: bsl::integral_constant<size_t,
                         bsl::is_same<t_TYPE, t_HEAD>::value +
                             Variant_CountType<t_TYPE, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 10
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10>
struct Variant_CountType<t_TYPE, t_HEAD, t_TAIL_01,
                                         t_TAIL_02,
                                         t_TAIL_03,
                                         t_TAIL_04,
                                         t_TAIL_05,
                                         t_TAIL_06,
                                         t_TAIL_07,
                                         t_TAIL_08,
                                         t_TAIL_09,
                                         t_TAIL_10>
: bsl::integral_constant<size_t,
                         bsl::is_same<t_TYPE, t_HEAD>::value +
                             Variant_CountType<t_TYPE, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 11
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11>
struct Variant_CountType<t_TYPE, t_HEAD, t_TAIL_01,
                                         t_TAIL_02,
                                         t_TAIL_03,
                                         t_TAIL_04,
                                         t_TAIL_05,
                                         t_TAIL_06,
                                         t_TAIL_07,
                                         t_TAIL_08,
                                         t_TAIL_09,
                                         t_TAIL_10,
                                         t_TAIL_11>
: bsl::integral_constant<size_t,
                         bsl::is_same<t_TYPE, t_HEAD>::value +
                             Variant_CountType<t_TYPE, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 12
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12>
struct Variant_CountType<t_TYPE, t_HEAD, t_TAIL_01,
                                         t_TAIL_02,
                                         t_TAIL_03,
                                         t_TAIL_04,
                                         t_TAIL_05,
                                         t_TAIL_06,
                                         t_TAIL_07,
                                         t_TAIL_08,
                                         t_TAIL_09,
                                         t_TAIL_10,
                                         t_TAIL_11,
                                         t_TAIL_12>
: bsl::integral_constant<size_t,
                         bsl::is_same<t_TYPE, t_HEAD>::value +
                             Variant_CountType<t_TYPE, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11,
                                                       t_TAIL_12>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 13
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13>
struct Variant_CountType<t_TYPE, t_HEAD, t_TAIL_01,
                                         t_TAIL_02,
                                         t_TAIL_03,
                                         t_TAIL_04,
                                         t_TAIL_05,
                                         t_TAIL_06,
                                         t_TAIL_07,
                                         t_TAIL_08,
                                         t_TAIL_09,
                                         t_TAIL_10,
                                         t_TAIL_11,
                                         t_TAIL_12,
                                         t_TAIL_13>
: bsl::integral_constant<size_t,
                         bsl::is_same<t_TYPE, t_HEAD>::value +
                             Variant_CountType<t_TYPE, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11,
                                                       t_TAIL_12,
                                                       t_TAIL_13>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 14
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14>
struct Variant_CountType<t_TYPE, t_HEAD, t_TAIL_01,
                                         t_TAIL_02,
                                         t_TAIL_03,
                                         t_TAIL_04,
                                         t_TAIL_05,
                                         t_TAIL_06,
                                         t_TAIL_07,
                                         t_TAIL_08,
                                         t_TAIL_09,
                                         t_TAIL_10,
                                         t_TAIL_11,
                                         t_TAIL_12,
                                         t_TAIL_13,
                                         t_TAIL_14>
: bsl::integral_constant<size_t,
                         bsl::is_same<t_TYPE, t_HEAD>::value +
                             Variant_CountType<t_TYPE, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11,
                                                       t_TAIL_12,
                                                       t_TAIL_13,
                                                       t_TAIL_14>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 15
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14,
                                      class t_TAIL_15>
struct Variant_CountType<t_TYPE, t_HEAD, t_TAIL_01,
                                         t_TAIL_02,
                                         t_TAIL_03,
                                         t_TAIL_04,
                                         t_TAIL_05,
                                         t_TAIL_06,
                                         t_TAIL_07,
                                         t_TAIL_08,
                                         t_TAIL_09,
                                         t_TAIL_10,
                                         t_TAIL_11,
                                         t_TAIL_12,
                                         t_TAIL_13,
                                         t_TAIL_14,
                                         t_TAIL_15>
: bsl::integral_constant<size_t,
                         bsl::is_same<t_TYPE, t_HEAD>::value +
                             Variant_CountType<t_TYPE, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11,
                                                       t_TAIL_12,
                                                       t_TAIL_13,
                                                       t_TAIL_14,
                                                       t_TAIL_15>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 16
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14,
                                      class t_TAIL_15,
                                      class t_TAIL_16>
struct Variant_CountType<t_TYPE, t_HEAD, t_TAIL_01,
                                         t_TAIL_02,
                                         t_TAIL_03,
                                         t_TAIL_04,
                                         t_TAIL_05,
                                         t_TAIL_06,
                                         t_TAIL_07,
                                         t_TAIL_08,
                                         t_TAIL_09,
                                         t_TAIL_10,
                                         t_TAIL_11,
                                         t_TAIL_12,
                                         t_TAIL_13,
                                         t_TAIL_14,
                                         t_TAIL_15,
                                         t_TAIL_16>
: bsl::integral_constant<size_t,
                         bsl::is_same<t_TYPE, t_HEAD>::value +
                             Variant_CountType<t_TYPE, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11,
                                                       t_TAIL_12,
                                                       t_TAIL_13,
                                                       t_TAIL_14,
                                                       t_TAIL_15,
                                                       t_TAIL_16>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 17
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14,
                                      class t_TAIL_15,
                                      class t_TAIL_16,
                                      class t_TAIL_17>
struct Variant_CountType<t_TYPE, t_HEAD, t_TAIL_01,
                                         t_TAIL_02,
                                         t_TAIL_03,
                                         t_TAIL_04,
                                         t_TAIL_05,
                                         t_TAIL_06,
                                         t_TAIL_07,
                                         t_TAIL_08,
                                         t_TAIL_09,
                                         t_TAIL_10,
                                         t_TAIL_11,
                                         t_TAIL_12,
                                         t_TAIL_13,
                                         t_TAIL_14,
                                         t_TAIL_15,
                                         t_TAIL_16,
                                         t_TAIL_17>
: bsl::integral_constant<size_t,
                         bsl::is_same<t_TYPE, t_HEAD>::value +
                             Variant_CountType<t_TYPE, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11,
                                                       t_TAIL_12,
                                                       t_TAIL_13,
                                                       t_TAIL_14,
                                                       t_TAIL_15,
                                                       t_TAIL_16,
                                                       t_TAIL_17>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 18
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14,
                                      class t_TAIL_15,
                                      class t_TAIL_16,
                                      class t_TAIL_17,
                                      class t_TAIL_18>
struct Variant_CountType<t_TYPE, t_HEAD, t_TAIL_01,
                                         t_TAIL_02,
                                         t_TAIL_03,
                                         t_TAIL_04,
                                         t_TAIL_05,
                                         t_TAIL_06,
                                         t_TAIL_07,
                                         t_TAIL_08,
                                         t_TAIL_09,
                                         t_TAIL_10,
                                         t_TAIL_11,
                                         t_TAIL_12,
                                         t_TAIL_13,
                                         t_TAIL_14,
                                         t_TAIL_15,
                                         t_TAIL_16,
                                         t_TAIL_17,
                                         t_TAIL_18>
: bsl::integral_constant<size_t,
                         bsl::is_same<t_TYPE, t_HEAD>::value +
                             Variant_CountType<t_TYPE, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11,
                                                       t_TAIL_12,
                                                       t_TAIL_13,
                                                       t_TAIL_14,
                                                       t_TAIL_15,
                                                       t_TAIL_16,
                                                       t_TAIL_17,
                                                       t_TAIL_18>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 18
 
 
template <class t_TYPE>
struct Variant_CountType<t_TYPE, BSLSTL_VARIANT_NOT_A_TYPE>
: bsl::integral_constant<size_t, 0> {
};
 
template <class t_TYPE, class t_VARIANT>
struct Variant_HasUniqueType;
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 0
template <class t_TYPE, class t_HEAD>
struct Variant_HasUniqueType<t_TYPE, bsl::variant<t_HEAD> >
: bsl::integral_constant<bool,
                         Variant_CountType<t_TYPE, t_HEAD>::value ==
                             1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 1
template <class t_TYPE, class t_HEAD, class t_TAIL_01>
struct Variant_HasUniqueType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01> >
: bsl::integral_constant<bool,
                         Variant_CountType<t_TYPE, t_HEAD, t_TAIL_01>::value ==
                             1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 2
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02>
struct Variant_HasUniqueType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02> >
: bsl::integral_constant<bool,
                         Variant_CountType<t_TYPE, t_HEAD, t_TAIL_01,
                                                           t_TAIL_02>::value ==
                             1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 3
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03>
struct Variant_HasUniqueType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03> >
: bsl::integral_constant<bool,
                         Variant_CountType<t_TYPE, t_HEAD, t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03>::value ==
                             1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 4
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04>
struct Variant_HasUniqueType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04> >
: bsl::integral_constant<bool,
                         Variant_CountType<t_TYPE, t_HEAD, t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04>::value ==
                             1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 5
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05>
struct Variant_HasUniqueType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05> >
: bsl::integral_constant<bool,
                         Variant_CountType<t_TYPE, t_HEAD, t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05>::value ==
                             1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 6
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06>
struct Variant_HasUniqueType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06> >
: bsl::integral_constant<bool,
                         Variant_CountType<t_TYPE, t_HEAD, t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06>::value ==
                             1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 7
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07>
struct Variant_HasUniqueType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07> >
: bsl::integral_constant<bool,
                         Variant_CountType<t_TYPE, t_HEAD, t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07>::value ==
                             1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 8
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08>
struct Variant_HasUniqueType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08> >
: bsl::integral_constant<bool,
                         Variant_CountType<t_TYPE, t_HEAD, t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08>::value ==
                             1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 9
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09>
struct Variant_HasUniqueType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09> >
: bsl::integral_constant<bool,
                         Variant_CountType<t_TYPE, t_HEAD, t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09>::value ==
                             1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 10
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10>
struct Variant_HasUniqueType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10> >
: bsl::integral_constant<bool,
                         Variant_CountType<t_TYPE, t_HEAD, t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10>::value ==
                             1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 11
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11>
struct Variant_HasUniqueType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11> >
: bsl::integral_constant<bool,
                         Variant_CountType<t_TYPE, t_HEAD, t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11>::value ==
                             1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 12
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12>
struct Variant_HasUniqueType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12> >
: bsl::integral_constant<bool,
                         Variant_CountType<t_TYPE, t_HEAD, t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12>::value ==
                             1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 13
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13>
struct Variant_HasUniqueType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13> >
: bsl::integral_constant<bool,
                         Variant_CountType<t_TYPE, t_HEAD, t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13>::value ==
                             1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 14
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14>
struct Variant_HasUniqueType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14> >
: bsl::integral_constant<bool,
                         Variant_CountType<t_TYPE, t_HEAD, t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14>::value ==
                             1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 15
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14,
                                      class t_TAIL_15>
struct Variant_HasUniqueType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15> >
: bsl::integral_constant<bool,
                         Variant_CountType<t_TYPE, t_HEAD, t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14,
                                                           t_TAIL_15>::value ==
                             1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 16
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14,
                                      class t_TAIL_15,
                                      class t_TAIL_16>
struct Variant_HasUniqueType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16> >
: bsl::integral_constant<bool,
                         Variant_CountType<t_TYPE, t_HEAD, t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14,
                                                           t_TAIL_15,
                                                           t_TAIL_16>::value ==
                             1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 17
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14,
                                      class t_TAIL_15,
                                      class t_TAIL_16,
                                      class t_TAIL_17>
struct Variant_HasUniqueType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17> >
: bsl::integral_constant<bool,
                         Variant_CountType<t_TYPE, t_HEAD, t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14,
                                                           t_TAIL_15,
                                                           t_TAIL_16,
                                                           t_TAIL_17>::value ==
                             1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 18
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14,
                                      class t_TAIL_15,
                                      class t_TAIL_16,
                                      class t_TAIL_17,
                                      class t_TAIL_18>
struct Variant_HasUniqueType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17,
                                                          t_TAIL_18> >
: bsl::integral_constant<bool,
                         Variant_CountType<t_TYPE, t_HEAD, t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14,
                                                           t_TAIL_15,
                                                           t_TAIL_16,
                                                           t_TAIL_17,
                                                           t_TAIL_18>::value ==
                             1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 18
 
 
template <class t_TYPE,
          class t_HEAD = BSLSTL_VARIANT_NOT_A_TYPE
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 0
        , class t_TAIL_0 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 1
        , class t_TAIL_1 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 2
        , class t_TAIL_2 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 3
        , class t_TAIL_3 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 4
        , class t_TAIL_4 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 5
        , class t_TAIL_5 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 6
        , class t_TAIL_6 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 7
        , class t_TAIL_7 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 8
        , class t_TAIL_8 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 9
        , class t_TAIL_9 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 10
        , class t_TAIL_10 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 11
        , class t_TAIL_11 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 12
        , class t_TAIL_12 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 13
        , class t_TAIL_13 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 14
        , class t_TAIL_14 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 15
        , class t_TAIL_15 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 16
        , class t_TAIL_16 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 17
        , class t_TAIL_17 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 17
        , class = BSLS_COMPILERFEATURES_NILT>
struct Variant_CountCVType;
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 0
template <class t_TYPE, class t_HEAD>
struct Variant_CountCVType<t_TYPE, t_HEAD>
: bsl::integral_constant<
      size_t,
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value +
          Variant_CountCVType<t_TYPE>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 1
template <class t_TYPE, class t_HEAD, class t_TAIL_01>
struct Variant_CountCVType<t_TYPE, t_HEAD, t_TAIL_01>
: bsl::integral_constant<
      size_t,
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value +
          Variant_CountCVType<t_TYPE, t_TAIL_01>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 2
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02>
struct Variant_CountCVType<t_TYPE, t_HEAD, t_TAIL_01,
                                           t_TAIL_02>
: bsl::integral_constant<
      size_t,
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value +
          Variant_CountCVType<t_TYPE, t_TAIL_01,
                                      t_TAIL_02>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 3
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03>
struct Variant_CountCVType<t_TYPE, t_HEAD, t_TAIL_01,
                                           t_TAIL_02,
                                           t_TAIL_03>
: bsl::integral_constant<
      size_t,
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value +
          Variant_CountCVType<t_TYPE, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 4
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04>
struct Variant_CountCVType<t_TYPE, t_HEAD, t_TAIL_01,
                                           t_TAIL_02,
                                           t_TAIL_03,
                                           t_TAIL_04>
: bsl::integral_constant<
      size_t,
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value +
          Variant_CountCVType<t_TYPE, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 5
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05>
struct Variant_CountCVType<t_TYPE, t_HEAD, t_TAIL_01,
                                           t_TAIL_02,
                                           t_TAIL_03,
                                           t_TAIL_04,
                                           t_TAIL_05>
: bsl::integral_constant<
      size_t,
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value +
          Variant_CountCVType<t_TYPE, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 6
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06>
struct Variant_CountCVType<t_TYPE, t_HEAD, t_TAIL_01,
                                           t_TAIL_02,
                                           t_TAIL_03,
                                           t_TAIL_04,
                                           t_TAIL_05,
                                           t_TAIL_06>
: bsl::integral_constant<
      size_t,
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value +
          Variant_CountCVType<t_TYPE, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 7
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07>
struct Variant_CountCVType<t_TYPE, t_HEAD, t_TAIL_01,
                                           t_TAIL_02,
                                           t_TAIL_03,
                                           t_TAIL_04,
                                           t_TAIL_05,
                                           t_TAIL_06,
                                           t_TAIL_07>
: bsl::integral_constant<
      size_t,
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value +
          Variant_CountCVType<t_TYPE, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 8
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08>
struct Variant_CountCVType<t_TYPE, t_HEAD, t_TAIL_01,
                                           t_TAIL_02,
                                           t_TAIL_03,
                                           t_TAIL_04,
                                           t_TAIL_05,
                                           t_TAIL_06,
                                           t_TAIL_07,
                                           t_TAIL_08>
: bsl::integral_constant<
      size_t,
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value +
          Variant_CountCVType<t_TYPE, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 9
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09>
struct Variant_CountCVType<t_TYPE, t_HEAD, t_TAIL_01,
                                           t_TAIL_02,
                                           t_TAIL_03,
                                           t_TAIL_04,
                                           t_TAIL_05,
                                           t_TAIL_06,
                                           t_TAIL_07,
                                           t_TAIL_08,
                                           t_TAIL_09>
: bsl::integral_constant<
      size_t,
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value +
          Variant_CountCVType<t_TYPE, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 10
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10>
struct Variant_CountCVType<t_TYPE, t_HEAD, t_TAIL_01,
                                           t_TAIL_02,
                                           t_TAIL_03,
                                           t_TAIL_04,
                                           t_TAIL_05,
                                           t_TAIL_06,
                                           t_TAIL_07,
                                           t_TAIL_08,
                                           t_TAIL_09,
                                           t_TAIL_10>
: bsl::integral_constant<
      size_t,
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value +
          Variant_CountCVType<t_TYPE, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 11
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11>
struct Variant_CountCVType<t_TYPE, t_HEAD, t_TAIL_01,
                                           t_TAIL_02,
                                           t_TAIL_03,
                                           t_TAIL_04,
                                           t_TAIL_05,
                                           t_TAIL_06,
                                           t_TAIL_07,
                                           t_TAIL_08,
                                           t_TAIL_09,
                                           t_TAIL_10,
                                           t_TAIL_11>
: bsl::integral_constant<
      size_t,
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value +
          Variant_CountCVType<t_TYPE, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 12
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12>
struct Variant_CountCVType<t_TYPE, t_HEAD, t_TAIL_01,
                                           t_TAIL_02,
                                           t_TAIL_03,
                                           t_TAIL_04,
                                           t_TAIL_05,
                                           t_TAIL_06,
                                           t_TAIL_07,
                                           t_TAIL_08,
                                           t_TAIL_09,
                                           t_TAIL_10,
                                           t_TAIL_11,
                                           t_TAIL_12>
: bsl::integral_constant<
      size_t,
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value +
          Variant_CountCVType<t_TYPE, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 13
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13>
struct Variant_CountCVType<t_TYPE, t_HEAD, t_TAIL_01,
                                           t_TAIL_02,
                                           t_TAIL_03,
                                           t_TAIL_04,
                                           t_TAIL_05,
                                           t_TAIL_06,
                                           t_TAIL_07,
                                           t_TAIL_08,
                                           t_TAIL_09,
                                           t_TAIL_10,
                                           t_TAIL_11,
                                           t_TAIL_12,
                                           t_TAIL_13>
: bsl::integral_constant<
      size_t,
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value +
          Variant_CountCVType<t_TYPE, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 14
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14>
struct Variant_CountCVType<t_TYPE, t_HEAD, t_TAIL_01,
                                           t_TAIL_02,
                                           t_TAIL_03,
                                           t_TAIL_04,
                                           t_TAIL_05,
                                           t_TAIL_06,
                                           t_TAIL_07,
                                           t_TAIL_08,
                                           t_TAIL_09,
                                           t_TAIL_10,
                                           t_TAIL_11,
                                           t_TAIL_12,
                                           t_TAIL_13,
                                           t_TAIL_14>
: bsl::integral_constant<
      size_t,
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value +
          Variant_CountCVType<t_TYPE, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 15
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14,
                                      class t_TAIL_15>
struct Variant_CountCVType<t_TYPE, t_HEAD, t_TAIL_01,
                                           t_TAIL_02,
                                           t_TAIL_03,
                                           t_TAIL_04,
                                           t_TAIL_05,
                                           t_TAIL_06,
                                           t_TAIL_07,
                                           t_TAIL_08,
                                           t_TAIL_09,
                                           t_TAIL_10,
                                           t_TAIL_11,
                                           t_TAIL_12,
                                           t_TAIL_13,
                                           t_TAIL_14,
                                           t_TAIL_15>
: bsl::integral_constant<
      size_t,
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value +
          Variant_CountCVType<t_TYPE, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 16
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14,
                                      class t_TAIL_15,
                                      class t_TAIL_16>
struct Variant_CountCVType<t_TYPE, t_HEAD, t_TAIL_01,
                                           t_TAIL_02,
                                           t_TAIL_03,
                                           t_TAIL_04,
                                           t_TAIL_05,
                                           t_TAIL_06,
                                           t_TAIL_07,
                                           t_TAIL_08,
                                           t_TAIL_09,
                                           t_TAIL_10,
                                           t_TAIL_11,
                                           t_TAIL_12,
                                           t_TAIL_13,
                                           t_TAIL_14,
                                           t_TAIL_15,
                                           t_TAIL_16>
: bsl::integral_constant<
      size_t,
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value +
          Variant_CountCVType<t_TYPE, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 17
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14,
                                      class t_TAIL_15,
                                      class t_TAIL_16,
                                      class t_TAIL_17>
struct Variant_CountCVType<t_TYPE, t_HEAD, t_TAIL_01,
                                           t_TAIL_02,
                                           t_TAIL_03,
                                           t_TAIL_04,
                                           t_TAIL_05,
                                           t_TAIL_06,
                                           t_TAIL_07,
                                           t_TAIL_08,
                                           t_TAIL_09,
                                           t_TAIL_10,
                                           t_TAIL_11,
                                           t_TAIL_12,
                                           t_TAIL_13,
                                           t_TAIL_14,
                                           t_TAIL_15,
                                           t_TAIL_16,
                                           t_TAIL_17>
: bsl::integral_constant<
      size_t,
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value +
          Variant_CountCVType<t_TYPE, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16,
                                      t_TAIL_17>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 18
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14,
                                      class t_TAIL_15,
                                      class t_TAIL_16,
                                      class t_TAIL_17,
                                      class t_TAIL_18>
struct Variant_CountCVType<t_TYPE, t_HEAD, t_TAIL_01,
                                           t_TAIL_02,
                                           t_TAIL_03,
                                           t_TAIL_04,
                                           t_TAIL_05,
                                           t_TAIL_06,
                                           t_TAIL_07,
                                           t_TAIL_08,
                                           t_TAIL_09,
                                           t_TAIL_10,
                                           t_TAIL_11,
                                           t_TAIL_12,
                                           t_TAIL_13,
                                           t_TAIL_14,
                                           t_TAIL_15,
                                           t_TAIL_16,
                                           t_TAIL_17,
                                           t_TAIL_18>
: bsl::integral_constant<
      size_t,
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value +
          Variant_CountCVType<t_TYPE, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16,
                                      t_TAIL_17,
                                      t_TAIL_18>::value> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 18
 
 
template <class t_TYPE>
struct Variant_CountCVType<t_TYPE, BSLSTL_VARIANT_NOT_A_TYPE>
: bsl::integral_constant<size_t, 0> {
};
 
template <class t_TYPE, class t_VARIANT>
struct Variant_HasUniqueCVType;
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 0
template <class t_TYPE, class t_HEAD>
struct Variant_HasUniqueCVType<t_TYPE, bsl::variant<t_HEAD> >
: bsl::integral_constant<
      bool,
      Variant_CountCVType<t_TYPE, t_HEAD>::value == 1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 1
template <class t_TYPE, class t_HEAD, class t_TAIL_01>
struct Variant_HasUniqueCVType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01> >
: bsl::integral_constant<
      bool,
      Variant_CountCVType<t_TYPE, t_HEAD, t_TAIL_01>::value == 1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 2
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02>
struct Variant_HasUniqueCVType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                            t_TAIL_02> >
: bsl::integral_constant<
      bool,
      Variant_CountCVType<t_TYPE, t_HEAD, t_TAIL_01,
                                          t_TAIL_02>::value == 1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 3
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03>
struct Variant_HasUniqueCVType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                            t_TAIL_02,
                                                            t_TAIL_03> >
: bsl::integral_constant<
      bool,
      Variant_CountCVType<t_TYPE, t_HEAD, t_TAIL_01,
                                          t_TAIL_02,
                                          t_TAIL_03>::value == 1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 4
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04>
struct Variant_HasUniqueCVType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                            t_TAIL_02,
                                                            t_TAIL_03,
                                                            t_TAIL_04> >
: bsl::integral_constant<
      bool,
      Variant_CountCVType<t_TYPE, t_HEAD, t_TAIL_01,
                                          t_TAIL_02,
                                          t_TAIL_03,
                                          t_TAIL_04>::value == 1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 5
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05>
struct Variant_HasUniqueCVType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                            t_TAIL_02,
                                                            t_TAIL_03,
                                                            t_TAIL_04,
                                                            t_TAIL_05> >
: bsl::integral_constant<
      bool,
      Variant_CountCVType<t_TYPE, t_HEAD, t_TAIL_01,
                                          t_TAIL_02,
                                          t_TAIL_03,
                                          t_TAIL_04,
                                          t_TAIL_05>::value == 1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 6
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06>
struct Variant_HasUniqueCVType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                            t_TAIL_02,
                                                            t_TAIL_03,
                                                            t_TAIL_04,
                                                            t_TAIL_05,
                                                            t_TAIL_06> >
: bsl::integral_constant<
      bool,
      Variant_CountCVType<t_TYPE, t_HEAD, t_TAIL_01,
                                          t_TAIL_02,
                                          t_TAIL_03,
                                          t_TAIL_04,
                                          t_TAIL_05,
                                          t_TAIL_06>::value == 1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 7
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07>
struct Variant_HasUniqueCVType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                            t_TAIL_02,
                                                            t_TAIL_03,
                                                            t_TAIL_04,
                                                            t_TAIL_05,
                                                            t_TAIL_06,
                                                            t_TAIL_07> >
: bsl::integral_constant<
      bool,
      Variant_CountCVType<t_TYPE, t_HEAD, t_TAIL_01,
                                          t_TAIL_02,
                                          t_TAIL_03,
                                          t_TAIL_04,
                                          t_TAIL_05,
                                          t_TAIL_06,
                                          t_TAIL_07>::value == 1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 8
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08>
struct Variant_HasUniqueCVType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                            t_TAIL_02,
                                                            t_TAIL_03,
                                                            t_TAIL_04,
                                                            t_TAIL_05,
                                                            t_TAIL_06,
                                                            t_TAIL_07,
                                                            t_TAIL_08> >
: bsl::integral_constant<
      bool,
      Variant_CountCVType<t_TYPE, t_HEAD, t_TAIL_01,
                                          t_TAIL_02,
                                          t_TAIL_03,
                                          t_TAIL_04,
                                          t_TAIL_05,
                                          t_TAIL_06,
                                          t_TAIL_07,
                                          t_TAIL_08>::value == 1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 9
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09>
struct Variant_HasUniqueCVType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                            t_TAIL_02,
                                                            t_TAIL_03,
                                                            t_TAIL_04,
                                                            t_TAIL_05,
                                                            t_TAIL_06,
                                                            t_TAIL_07,
                                                            t_TAIL_08,
                                                            t_TAIL_09> >
: bsl::integral_constant<
      bool,
      Variant_CountCVType<t_TYPE, t_HEAD, t_TAIL_01,
                                          t_TAIL_02,
                                          t_TAIL_03,
                                          t_TAIL_04,
                                          t_TAIL_05,
                                          t_TAIL_06,
                                          t_TAIL_07,
                                          t_TAIL_08,
                                          t_TAIL_09>::value == 1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 10
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10>
struct Variant_HasUniqueCVType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                            t_TAIL_02,
                                                            t_TAIL_03,
                                                            t_TAIL_04,
                                                            t_TAIL_05,
                                                            t_TAIL_06,
                                                            t_TAIL_07,
                                                            t_TAIL_08,
                                                            t_TAIL_09,
                                                            t_TAIL_10> >
: bsl::integral_constant<
      bool,
      Variant_CountCVType<t_TYPE, t_HEAD, t_TAIL_01,
                                          t_TAIL_02,
                                          t_TAIL_03,
                                          t_TAIL_04,
                                          t_TAIL_05,
                                          t_TAIL_06,
                                          t_TAIL_07,
                                          t_TAIL_08,
                                          t_TAIL_09,
                                          t_TAIL_10>::value == 1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 11
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11>
struct Variant_HasUniqueCVType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                            t_TAIL_02,
                                                            t_TAIL_03,
                                                            t_TAIL_04,
                                                            t_TAIL_05,
                                                            t_TAIL_06,
                                                            t_TAIL_07,
                                                            t_TAIL_08,
                                                            t_TAIL_09,
                                                            t_TAIL_10,
                                                            t_TAIL_11> >
: bsl::integral_constant<
      bool,
      Variant_CountCVType<t_TYPE, t_HEAD, t_TAIL_01,
                                          t_TAIL_02,
                                          t_TAIL_03,
                                          t_TAIL_04,
                                          t_TAIL_05,
                                          t_TAIL_06,
                                          t_TAIL_07,
                                          t_TAIL_08,
                                          t_TAIL_09,
                                          t_TAIL_10,
                                          t_TAIL_11>::value == 1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 12
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12>
struct Variant_HasUniqueCVType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                            t_TAIL_02,
                                                            t_TAIL_03,
                                                            t_TAIL_04,
                                                            t_TAIL_05,
                                                            t_TAIL_06,
                                                            t_TAIL_07,
                                                            t_TAIL_08,
                                                            t_TAIL_09,
                                                            t_TAIL_10,
                                                            t_TAIL_11,
                                                            t_TAIL_12> >
: bsl::integral_constant<
      bool,
      Variant_CountCVType<t_TYPE, t_HEAD, t_TAIL_01,
                                          t_TAIL_02,
                                          t_TAIL_03,
                                          t_TAIL_04,
                                          t_TAIL_05,
                                          t_TAIL_06,
                                          t_TAIL_07,
                                          t_TAIL_08,
                                          t_TAIL_09,
                                          t_TAIL_10,
                                          t_TAIL_11,
                                          t_TAIL_12>::value == 1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 13
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13>
struct Variant_HasUniqueCVType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                            t_TAIL_02,
                                                            t_TAIL_03,
                                                            t_TAIL_04,
                                                            t_TAIL_05,
                                                            t_TAIL_06,
                                                            t_TAIL_07,
                                                            t_TAIL_08,
                                                            t_TAIL_09,
                                                            t_TAIL_10,
                                                            t_TAIL_11,
                                                            t_TAIL_12,
                                                            t_TAIL_13> >
: bsl::integral_constant<
      bool,
      Variant_CountCVType<t_TYPE, t_HEAD, t_TAIL_01,
                                          t_TAIL_02,
                                          t_TAIL_03,
                                          t_TAIL_04,
                                          t_TAIL_05,
                                          t_TAIL_06,
                                          t_TAIL_07,
                                          t_TAIL_08,
                                          t_TAIL_09,
                                          t_TAIL_10,
                                          t_TAIL_11,
                                          t_TAIL_12,
                                          t_TAIL_13>::value == 1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 14
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14>
struct Variant_HasUniqueCVType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                            t_TAIL_02,
                                                            t_TAIL_03,
                                                            t_TAIL_04,
                                                            t_TAIL_05,
                                                            t_TAIL_06,
                                                            t_TAIL_07,
                                                            t_TAIL_08,
                                                            t_TAIL_09,
                                                            t_TAIL_10,
                                                            t_TAIL_11,
                                                            t_TAIL_12,
                                                            t_TAIL_13,
                                                            t_TAIL_14> >
: bsl::integral_constant<
      bool,
      Variant_CountCVType<t_TYPE, t_HEAD, t_TAIL_01,
                                          t_TAIL_02,
                                          t_TAIL_03,
                                          t_TAIL_04,
                                          t_TAIL_05,
                                          t_TAIL_06,
                                          t_TAIL_07,
                                          t_TAIL_08,
                                          t_TAIL_09,
                                          t_TAIL_10,
                                          t_TAIL_11,
                                          t_TAIL_12,
                                          t_TAIL_13,
                                          t_TAIL_14>::value == 1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 15
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14,
                                      class t_TAIL_15>
struct Variant_HasUniqueCVType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                            t_TAIL_02,
                                                            t_TAIL_03,
                                                            t_TAIL_04,
                                                            t_TAIL_05,
                                                            t_TAIL_06,
                                                            t_TAIL_07,
                                                            t_TAIL_08,
                                                            t_TAIL_09,
                                                            t_TAIL_10,
                                                            t_TAIL_11,
                                                            t_TAIL_12,
                                                            t_TAIL_13,
                                                            t_TAIL_14,
                                                            t_TAIL_15> >
: bsl::integral_constant<
      bool,
      Variant_CountCVType<t_TYPE, t_HEAD, t_TAIL_01,
                                          t_TAIL_02,
                                          t_TAIL_03,
                                          t_TAIL_04,
                                          t_TAIL_05,
                                          t_TAIL_06,
                                          t_TAIL_07,
                                          t_TAIL_08,
                                          t_TAIL_09,
                                          t_TAIL_10,
                                          t_TAIL_11,
                                          t_TAIL_12,
                                          t_TAIL_13,
                                          t_TAIL_14,
                                          t_TAIL_15>::value == 1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 16
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14,
                                      class t_TAIL_15,
                                      class t_TAIL_16>
struct Variant_HasUniqueCVType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                            t_TAIL_02,
                                                            t_TAIL_03,
                                                            t_TAIL_04,
                                                            t_TAIL_05,
                                                            t_TAIL_06,
                                                            t_TAIL_07,
                                                            t_TAIL_08,
                                                            t_TAIL_09,
                                                            t_TAIL_10,
                                                            t_TAIL_11,
                                                            t_TAIL_12,
                                                            t_TAIL_13,
                                                            t_TAIL_14,
                                                            t_TAIL_15,
                                                            t_TAIL_16> >
: bsl::integral_constant<
      bool,
      Variant_CountCVType<t_TYPE, t_HEAD, t_TAIL_01,
                                          t_TAIL_02,
                                          t_TAIL_03,
                                          t_TAIL_04,
                                          t_TAIL_05,
                                          t_TAIL_06,
                                          t_TAIL_07,
                                          t_TAIL_08,
                                          t_TAIL_09,
                                          t_TAIL_10,
                                          t_TAIL_11,
                                          t_TAIL_12,
                                          t_TAIL_13,
                                          t_TAIL_14,
                                          t_TAIL_15,
                                          t_TAIL_16>::value == 1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 17
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14,
                                      class t_TAIL_15,
                                      class t_TAIL_16,
                                      class t_TAIL_17>
struct Variant_HasUniqueCVType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                            t_TAIL_02,
                                                            t_TAIL_03,
                                                            t_TAIL_04,
                                                            t_TAIL_05,
                                                            t_TAIL_06,
                                                            t_TAIL_07,
                                                            t_TAIL_08,
                                                            t_TAIL_09,
                                                            t_TAIL_10,
                                                            t_TAIL_11,
                                                            t_TAIL_12,
                                                            t_TAIL_13,
                                                            t_TAIL_14,
                                                            t_TAIL_15,
                                                            t_TAIL_16,
                                                            t_TAIL_17> >
: bsl::integral_constant<
      bool,
      Variant_CountCVType<t_TYPE, t_HEAD, t_TAIL_01,
                                          t_TAIL_02,
                                          t_TAIL_03,
                                          t_TAIL_04,
                                          t_TAIL_05,
                                          t_TAIL_06,
                                          t_TAIL_07,
                                          t_TAIL_08,
                                          t_TAIL_09,
                                          t_TAIL_10,
                                          t_TAIL_11,
                                          t_TAIL_12,
                                          t_TAIL_13,
                                          t_TAIL_14,
                                          t_TAIL_15,
                                          t_TAIL_16,
                                          t_TAIL_17>::value == 1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 18
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14,
                                      class t_TAIL_15,
                                      class t_TAIL_16,
                                      class t_TAIL_17,
                                      class t_TAIL_18>
struct Variant_HasUniqueCVType<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                            t_TAIL_02,
                                                            t_TAIL_03,
                                                            t_TAIL_04,
                                                            t_TAIL_05,
                                                            t_TAIL_06,
                                                            t_TAIL_07,
                                                            t_TAIL_08,
                                                            t_TAIL_09,
                                                            t_TAIL_10,
                                                            t_TAIL_11,
                                                            t_TAIL_12,
                                                            t_TAIL_13,
                                                            t_TAIL_14,
                                                            t_TAIL_15,
                                                            t_TAIL_16,
                                                            t_TAIL_17,
                                                            t_TAIL_18> >
: bsl::integral_constant<
      bool,
      Variant_CountCVType<t_TYPE, t_HEAD, t_TAIL_01,
                                          t_TAIL_02,
                                          t_TAIL_03,
                                          t_TAIL_04,
                                          t_TAIL_05,
                                          t_TAIL_06,
                                          t_TAIL_07,
                                          t_TAIL_08,
                                          t_TAIL_09,
                                          t_TAIL_10,
                                          t_TAIL_11,
                                          t_TAIL_12,
                                          t_TAIL_13,
                                          t_TAIL_14,
                                          t_TAIL_15,
                                          t_TAIL_16,
                                          t_TAIL_17,
                                          t_TAIL_18>::value == 1> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_F >= 18
 
#else
// The generated code below is a workaround for the absence of perfect
// forwarding in some compilers.
template <class t_HEAD = BSLSTL_VARIANT_NOT_A_TYPE, class... t_TAIL>
struct Variant_UsesBslmaAllocatorAny;
 
template <>
struct Variant_UsesBslmaAllocatorAny<BSLSTL_VARIANT_NOT_A_TYPE>
: bsl::false_type {
};
 
template <class t_HEAD, class... t_TAIL>
struct Variant_UsesBslmaAllocatorAny
: bsl::integral_constant<
      bool,
      BloombergLP::bslma::UsesBslmaAllocator<t_HEAD>::value ||
          BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<
          t_TAIL...>::value> {
};
 
template <class t_HEAD = BSLSTL_VARIANT_NOT_A_TYPE, class... t_TAIL>
struct Variant_IsBitwiseMoveableAll;
 
template <>
struct Variant_IsBitwiseMoveableAll<BSLSTL_VARIANT_NOT_A_TYPE>
: bsl::true_type {
};
 
template <class t_HEAD, class... t_TAIL>
struct Variant_IsBitwiseMoveableAll
: bsl::integral_constant<
      bool,
      BloombergLP::bslmf::IsBitwiseMoveable<t_HEAD>::value &&
          Variant_IsBitwiseMoveableAll<t_TAIL...>::value> {
};
 
template <class t_TYPE>
struct Variant_IsTag : bsl::false_type {
};
 
template <>
struct Variant_IsTag<bsl::allocator_arg_t> : bsl::true_type {
};
 
template <class t_TYPE>
struct Variant_IsTag<bsl::in_place_type_t<t_TYPE> > : bsl::true_type {
};
 
template <size_t t_INDEX>
struct Variant_IsTag<bsl::in_place_index_t<t_INDEX> > : bsl::true_type {
};
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
template <class t_TO, class t_FROM>
struct Variant_IsConstructible : std::is_constructible<t_TO, t_FROM> {
};
 
template <class t_LHS, class t_RHS>
struct Variant_IsAssignable : std::is_assignable<t_LHS, t_RHS> {
};
#else
template <class t_TO, class t_FROM>
struct Variant_IsConstructible : bsl::true_type {
};
 
template <class t_LHS, class t_RHS>
struct Variant_IsAssignable : bsl::true_type {
};
#endif
 
#define BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(VARIANT, TYPE)               \
    typename bsl::enable_if<                                                  \
        BloombergLP::bslstl::Variant_ConstructsFromType<VARIANT,              \
                                                        TYPE>::value,         \
        BloombergLP::bslstl::Variant_NoSuchType>::type
 
#define BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(VARIANT, TYPE)              \
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(                                 \
                        VARIANT,                                              \
                        TYPE) = BloombergLP::bslstl::Variant_NoSuchType(0)
 
#define BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM_STD(STD_VARIANT)             \
    bsl::enable_if_t<                                                         \
        BloombergLP::bslstl::variant_constructsFromStd<variant, STD_VARIANT>, \
        BloombergLP::bslstl::Variant_NoSuchType>
 
#define BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(STD_VARIANT)            \
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM_STD(STD_VARIANT)                 \
        = BloombergLP::bslstl::Variant_NoSuchType(0)
 
#define BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(TYPE)                        \
    typename bsl::enable_if<                                                  \
        BloombergLP::bslstl::Variant_HasUniqueType<TYPE, variant>::value,     \
        BloombergLP::bslstl::Variant_NoSuchType>::type
 
#define BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(TYPE)                       \
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(                                 \
                           TYPE) = BloombergLP::bslstl::Variant_NoSuchType(0)
 
#define BSLSTL_VARIANT_HAS_UNIQUE_TYPE(TYPE)                                  \
    BloombergLP::bslstl::                                                     \
        Variant_HasUniqueType<TYPE, variant<t_HEAD, t_TAIL...> >::value
 
#define BSLSTL_VARIANT_TYPE_AT_INDEX(INDEX)                                   \
    typename bsl::variant_alternative<INDEX,                                  \
                                      bsl::variant<t_HEAD, t_TAIL...> >::type
 
#define BSLSTL_VARIANT_INDEX_OF(TYPE, VARIANT)                                \
    BloombergLP::bslstl::Variant_TypeToIndex<TYPE, VARIANT>::value
 
#define BSLSTL_VARIANT_CONVERT_INDEX_OF(TYPE, VARIANT)                        \
    BloombergLP::bslstl::Variant_ConvertIndex<TYPE, VARIANT>::value
 
#define BSLSTL_VARIANT_CONVERT_TYPE_OF(TYPE, VARIANT)                         \
    typename bsl::variant_alternative<BSLSTL_VARIANT_CONVERT_INDEX_OF(        \
                                          TYPE, VARIANT),                     \
                                      VARIANT>::type
 
#define BSLSTL_VARIANT_VISITID(RET, VISITOR, VAROBJ)                          \
    BloombergLP::bslstl::Variant_ImpUtil::visitId<RET>(VISITOR, VAROBJ);
 
template <size_t t_INDEX,
          class t_TYPE,
          class t_HEAD = BSLSTL_VARIANT_NOT_A_TYPE,
          class... t_TAIL>
struct Variant_TypeToIndexImpl
: bsl::conditional<
      bsl::is_same<t_TYPE, t_HEAD>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_TypeToIndexImpl<t_INDEX + 1, t_TYPE, t_TAIL...> >::type {
};
 
template <size_t t_INDEX, class t_TYPE>
struct Variant_TypeToIndexImpl<t_INDEX, t_TYPE, BSLSTL_VARIANT_NOT_A_TYPE>
: bsl::integral_constant<size_t, bsl::variant_npos> {
};
 
template <class t_TYPE, class t_VARIANT>
struct Variant_TypeToIndex;
 
template <class t_TYPE, class t_HEAD, class... t_TAIL>
struct Variant_TypeToIndex<t_TYPE, bsl::variant<t_HEAD, t_TAIL...> >
: Variant_TypeToIndexImpl<0, t_TYPE, t_HEAD, t_TAIL...> {
};
 
template <class t_TYPE,
          class t_HEAD = BSLSTL_VARIANT_NOT_A_TYPE,
          class... t_TAIL>
struct Variant_CountType
: bsl::integral_constant<size_t,
                         bsl::is_same<t_TYPE, t_HEAD>::value +
                             Variant_CountType<t_TYPE, t_TAIL...>::value> {
};
 
template <class t_TYPE>
struct Variant_CountType<t_TYPE, BSLSTL_VARIANT_NOT_A_TYPE>
: bsl::integral_constant<size_t, 0> {
};
 
template <class t_TYPE, class t_VARIANT>
struct Variant_HasUniqueType;
 
template <class t_TYPE, class t_HEAD, class... t_TAIL>
struct Variant_HasUniqueType<t_TYPE, bsl::variant<t_HEAD, t_TAIL...> >
: bsl::integral_constant<bool,
                         Variant_CountType<t_TYPE, t_HEAD, t_TAIL...>::value ==
                             1> {
};
 
template <class t_TYPE,
          class t_HEAD = BSLSTL_VARIANT_NOT_A_TYPE,
          class... t_TAIL>
struct Variant_CountCVType
: bsl::integral_constant<
      size_t,
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value +
          Variant_CountCVType<t_TYPE, t_TAIL...>::value> {
};
 
template <class t_TYPE>
struct Variant_CountCVType<t_TYPE, BSLSTL_VARIANT_NOT_A_TYPE>
: bsl::integral_constant<size_t, 0> {
};
 
template <class t_TYPE, class t_VARIANT>
struct Variant_HasUniqueCVType;
 
template <class t_TYPE, class t_HEAD, class... t_TAIL>
struct Variant_HasUniqueCVType<t_TYPE, bsl::variant<t_HEAD, t_TAIL...> >
: bsl::integral_constant<
      bool,
      Variant_CountCVType<t_TYPE, t_HEAD, t_TAIL...>::value == 1> {
};
// }}} END GENERATED CODE
#endif
 
/// This component-private metafunction calculates the alternative type at
/// index (template parameter) `t_INDEX` in (template parameter)
/// `t_VARIANT`, where the cv- and ref-qualifiers of `t_VARIANT` are added
/// to the alternative type.  This metafunction is used to calculate the
/// return type of `bsl::visit`.
template <class t_VARIANT, size_t t_INDEX>
struct Variant_CVQualAlt {
 
    /// Alternative at `t_INDEX` with combined cv-qualifiers
    typedef typename bsl::variant_alternative<
        t_INDEX,
        typename bslmf::MovableRefUtil::RemoveReference<t_VARIANT>::type>::type
        CVAlt;
 
    typedef typename bsl::conditional<
        bslmf::MovableRefUtil::IsReference<t_VARIANT>::value,
        typename bsl::conditional<
            bslmf::MovableRefUtil::IsMovableReference<t_VARIANT>::value,
            typename bslmf::MovableRefUtil::AddMovableReference<CVAlt>::type,
            typename bslmf::MovableRefUtil::AddLvalueReference<CVAlt>::type>::
            type,
        CVAlt>::type type;
};
 
/// This component-private metafunction derives from `bsl::true_type` if,
/// for each alternative `ALTi` in (template parameter) `t_VARIANT` with
/// index less than or equal to (template parameter) `t_INDEX`,
/// `decltype(std::declval<t_VISITOR>(std::declval<ALTi>()))` is `t_RET`;
/// otherwise, this metafunction derives from `bsl::false_type`.  Note that
/// `ALTi` has the cv- and ref-qualifiers from `t_VARIANT` added to it.
/// This metafunction is used to determine whether invoking the visitor
/// results in the same type and value category for all alternatives.
template <class t_RET,
          class t_VISITOR,
          class t_VARIANT,
          size_t t_INDEX =
               bsl::variant_size<typename bslmf::MovableRefUtil::
                                     RemoveReference<t_VARIANT>::type>::value -
               1>
struct Variant_IsSameReturnType
: public bsl::integral_constant<
      bool,
      bsl::is_same<t_RET,
                   typename bsl::invoke_result<
                       t_VISITOR,
                       typename Variant_CVQualAlt<t_VARIANT, t_INDEX>::type>::
                       type>::value &&
          Variant_IsSameReturnType<t_RET, t_VISITOR, t_VARIANT, t_INDEX - 1>::
              value> {
};
template <class t_RET, class t_VISITOR, class t_VARIANT>
struct Variant_IsSameReturnType<t_RET, t_VISITOR, t_VARIANT, 0>
: bsl::is_same<t_RET,
               typename bsl::invoke_result<
                   t_VISITOR,
                   typename Variant_CVQualAlt<t_VARIANT, 0>::type>::type> {
};
 
                           // ======================
                           // struct Variant_ImpUtil
                           // ======================
 
/// This `struct` provides a namespace for utility functions used implement
/// various operations on `bsl::variant`.
struct Variant_ImpUtil {
 
    /// Return a reference to the alternative with index (template
    /// parameter) `t_INDEX` in the specified `variant`.  If `t_INDEX` is
    /// not the index of the currently active alternative, throw an
    /// exception of type `bad_variant_access`.  Note that the return type
    /// must be explicitly specified.
    template <class t_RET, size_t t_INDEX, class t_VARIANT>
    static t_RET& get(t_VARIANT& variant);
    template <class t_RET, size_t t_INDEX, class t_VARIANT>
    static t_RET& get(const t_VARIANT& variant);
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    /// Invoke the specified `visitor` on the active alternative of the
    /// specified `variant`, implicitly converting the return type to the
    /// explicitly specified (template parameter) `t_RET`.  The behavior is
    /// undefined unless `variant` holds a value.  Note that the return type
    /// must be explicitly specified.  This function does not require friend
    /// access to `Variant` and has been added to `Variant_ImpUtil` for the
    /// purposes of avoiding free functions.
    template <class t_RET, class t_VISITOR, class t_VARIANT>
    static t_RET visit(t_VISITOR&& visitor, t_VARIANT&& variant);
 
    /// Invoke the specified `visitor` on the active alternative of the
    /// specified `variant`, implicitly converting the return type to the
    /// explicitly specified (template parameter) `t_RET`, and pass a tag
    /// representing the index of the selected alternative when invoking the
    /// visitor.  It is used internally for visitors that participate in the
    /// `variant` implementation.  The behavior is undefined unless
    /// `variant` holds a value.  This function does not require friend
    /// access to `Variant` and has been added to `Variant_ImpUtil` for the
    /// purposes of avoiding free functions.
    template <class t_RET, class t_VISITOR, class t_VARIANT>
    static t_RET visitId(t_VISITOR&& visitor, t_VARIANT&& variant);
#else
    // Lack of perfect forwarding in C++03 means overload set must be
    // different.
    template <class t_RET, class t_VISITOR, class t_VARIANT>
    static t_RET visit(t_VISITOR& visitor, t_VARIANT& variant);
    template <class t_RET, class t_VISITOR, class t_VARIANT>
    static t_RET visit(t_VISITOR& visitor, const t_VARIANT& variant);
        // Invoke the specified 'visitor' on the active alternative of the
        // specified 'variant', implicitly converting the return type to the
        // explicitly specified (template parameter) 't_RET'.  The behavior is
        // undefined if 'variant' does not hold a value.  This function does
        // not require friend access to 'Variant' and has been added to
        // 'Variant_ImpUtil' for the purposes of avoiding free functions.
 
    template <class t_RET, class t_VISITOR, class t_VARIANT>
    static t_RET moveVisit(t_VISITOR& visitor, t_VARIANT& variant);
        // Invoke the specified 'visitor' on a 'bslmf::MovableRef' referring to
        // the active alternative of the specified 'variant', implicitly
        // converting the return type to the explicitly specified (template
        // parameter) 't_RET'.  The behavior is undefined if 'variant' does not
        // hold a value.  This function does not require friend access to
        // 'Variant' and has been added to 'Variant_ImpUtil' for the purposes
        // of avoiding free functions.
 
    template <class t_RET, class t_VISITOR, class t_VARIANT>
    static t_RET visitId(t_VISITOR& visitor, t_VARIANT& variant);
    template <class t_RET, class t_VISITOR, class t_VARIANT>
    static t_RET visitId(t_VISITOR& visitor, const t_VARIANT& variant);
        // Invoke the specified 'visitor' with a
        // 'bsl::in_place_index_t<t_INDEX>' tag (where 't_INDEX' is the index
        // of the first alternative that has the same type as the active
        // alternative of the specified 'variant') and the active alternative
        // of 'variant', implicitly converting the return type to the
        // explicitly specified (template parameter) 't_RET'.  The behavior is
        // undefined if 'variant' does not hold a value.  This function does
        // not require friend access to 'Variant' and has been added to
        // 'Variant_ImpUtil' for the purposes of avoiding free functions.
 
#endif  // BSL_VARIANT_FULL_IMPLEMENTATION
 
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
    // In C++03, the internal visitation dispatch must call a type-based (not
    // index-based) getter.  This internal type-based getter will always be
    // passed the type of the currently active alternative, so there is no need
    // to check whether the requested alternative matches the currently active
    // alternative.  Moreover, in cases where there are alternatives of
    // identical type, 'bsl::get' cannot be passed such a type.  To solve the
    // problem, we implement an unsafe type-based getter that is used only for
    // internal visitation.
 
    template <class t_RET, size_t t_INDEX, class t_VARIANT>
    static t_RET& unsafeGet(t_VARIANT& variant);
    template <class t_RET, size_t t_INDEX, class t_VARIANT>
    static t_RET& unsafeGet(const t_VARIANT& variant);
        // Return a reference to type (template parameter) 't_RET' to the
        // alternative at (template parameter) 't_INDEX' in the specified
        // 'variant', regardless of whether that is the active alternative.
        // The behavior is undefined unless the active alternative of 'variant'
        // has the same type as the alternative with index 't_INDEX'.  Note
        // that the return type must be explicitly specified.
 
    template <class t_TYPE, class t_VARIANT>
    static t_TYPE& unsafeGet(t_VARIANT& obj);
    template <class t_TYPE, class t_VARIANT>
    static const t_TYPE& unsafeGet(const t_VARIANT& obj);
        // Return a reference to const-qualified (template parameter) 't_TYPE'
        // to the first alternative of the specified 'obj' that has type
        // 't_TYPE', regardless of whether that is the active alternative.  The
        // behavior is undefined unless the active alternative of 'variant' is
        // of type 't_TYPE'.  This function does not require friend access to
        // 'Variant' and has been added to 'Variant_ImpUtil' for the purposes
        // of avoiding free functions.
 
#endif  // BSL_VARIANT_FULL_IMPLEMENTATION
 
    /// Return a reference to the object managed by the first member of the
    /// specified `variantUnion`.  It is the base case for the overload of
    /// `getAlternative` below.  This function does not require friend
    /// access to `Variant` and has been added to `Variant_ImpUtil` for the
    /// purposes of avoiding free functions.
    template <class t_RET, class t_VARIANT_UNION>
    static t_RET& getAlternative(
                  bsl::in_place_index_t<0>,
                  t_VARIANT_UNION&          variantUnion) BSLS_KEYWORD_NOEXCEPT;
 
    /// Return a reference to the alternative with index (template
    /// parameter) `t_INDEX` in the specified `variantUnion` by recursively
    /// unravelling `variantUnion` until the desired alternative is at the
    /// head.  `t_INDEX` shall be a valid alternative index.  The behavior
    /// is undefined unless the alternative with index `t_INDEX` has the
    /// same type as the active alternative of `variantUnion`.  This
    /// function does not require friend access to `Variant` and has been
    /// added to `Variant_ImpUtil` for the purposes of avoiding free
    /// functions.
    template <class t_RET, size_t t_INDEX, class t_VARIANT_UNION>
    static t_RET& getAlternative(
            bsl::in_place_index_t<t_INDEX>,
            t_VARIANT_UNION&               variantUnion) BSLS_KEYWORD_NOEXCEPT;
 
    template <class t_VARIANT>
    static bool Equal(const t_VARIANT& lhs, const t_VARIANT& rhs);
    template <class t_VARIANT>
    static bool NotEqual(const t_VARIANT& lhs, const t_VARIANT& rhs);
    template <class t_VARIANT>
    static bool LessThan(const t_VARIANT& lhs, const t_VARIANT& rhs);
    template <class t_VARIANT>
    static bool GreaterThan(const t_VARIANT& lhs, const t_VARIANT& rhs);
    template <class t_VARIANT>
    static bool LessOrEqual(const t_VARIANT& lhs, const t_VARIANT& rhs);
 
    /// Return the result of comparing the specified `lhs` with the
    /// specified `rhs`.  The behavior is undefined unless both `lhs` and
    /// `rhs` hold the same alternative.  Note that the capitalization of
    /// the names of these methods has been chosen so that their definitions
    /// can be generated using a macro.
    template <class t_VARIANT>
    static bool GreaterOrEqual(const t_VARIANT& lhs, const t_VARIANT& rhs);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    /// This visitor is used to implement the explicit constructor for
    /// `bsl::variant` from `std::variant`.
    template <class t_VARIANT, class t_STD_VARIANT>
    class ConstructFromStdVisitor;
#endif  // BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
};
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
 
               // ==============================================
               // class Variant_ImpUtil::ConstructFromStdVisitor
               // ==============================================
 
template <class t_VARIANT, class t_STD_VARIANT>
class Variant_ImpUtil::ConstructFromStdVisitor {
  private:
    // DATA
    t_VARIANT&     d_target;
    t_STD_VARIANT& d_original;
 
  public:
    // CREATORS
 
    /// Create a `ConstructFromStdVisitor` object that, when invoked, will
    /// construct the alternative of the specified `target` corresponding to
    /// the active alternative of the specified `original`.  `target` shall
    /// have the same sequence of alternative types as `original`.
    explicit ConstructFromStdVisitor(t_VARIANT&     target,
                                     t_STD_VARIANT& original);
 
    // ACCESSORS
 
    /// Construct the alternative at index (template parameter) `t_INDEX`
    /// in `d_target` from the contained value of `d_original`.  If
    /// `t_STD_VARIANT` is an lvalue reference type, the alternative will be
    /// created by copy construction, otherwise it will be created by move
    /// construction.  The behavior is undefined unless `d_original` holds a
    /// value and `d_target.index() == d_original.index()`.  Note that the
    /// unused parameter of type `t_TYPE&` refers to the alternative that
    /// will be constructed, but we do not construct directly into that
    /// object because we need to make sure that the allocator of `d_target`
    /// (if any) is used.
    template <size_t t_INDEX, class t_TYPE>
    void operator()(bsl::in_place_index_t<t_INDEX>, t_TYPE&) const;
};
#endif  // BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
/// This component-private struct is used to check whether an alternative
/// given by (template parameter) `t_TYPE` is a potential match for an
/// argument of a `bsl::variant` constructor or assignment operator that
/// does not take an explicitly specified alternative type.  The standard
/// allows such conversion only when the declaration `t_TYPE d_x[] = {expr};`
/// is valid, where `expr` is the (forwarded) argument expression.
template <class t_TYPE>
struct Variant_ArrayHelper {
    t_TYPE d_x[1];
};
 
/// This component-private metafunction checks whether a conversion from a
/// pointer type to (template parameter) `t_TYPE` is narrowing.  It is
/// instantiated only for `bool`, and its behavior depends on whether the
/// compiler has implemented P1957R2.
template <class t_TYPE, class = void>
struct Variant_CheckForP1957R2 : bsl::true_type {
};
 
template <class t_TYPE>
struct Variant_CheckForP1957R2<
    t_TYPE,
    bsl::void_t<decltype(Variant_ArrayHelper<t_TYPE>{{"bc"}})> >
: bsl::false_type {
};
 
template <class t_DEST, class t_SOURCE, class = void>
struct Variant_ConvertsWithoutNarrowing : bsl::false_type {
};
 
/// This component-private metafunction is derived from `bsl::true_type` if
/// (template parameter) `t_SOURCE` can be converted to (template parameter)
/// `t_DEST` without narrowing, and `bsl::false_type` otherwise.  A
/// conversion from pointer or pointer-to-member type to cv `bool` is
/// considered narrowing even if the compiler does not implement P1957R2
/// (which was adopted as a DR); however, on compilers that do not implement
/// P1957R2, we do not have the ability to check whether a user-defined
/// conversion sequence to cv `bool` would use a narrowing standard
/// conversion, so on those compilers, we permit conversion to a `t_DEST`
/// that is cv `bool` only if `t_SOURCE` is also cv `bool`, and not when
/// `t_SOURCE` is a class type.  This behavior is not expected to pose a
/// problem for users migrating from `bdlb::Variant`, because that class
/// does not support implicit conversions from an argument type to an
/// alternative type.
template <class t_DEST, class t_SOURCE>
struct Variant_ConvertsWithoutNarrowing<
    t_DEST,
    t_SOURCE,
    bsl::void_t<decltype(
        Variant_ArrayHelper<t_DEST>{{std::declval<t_SOURCE>()}})> >
: bsl::integral_constant<
      bool,
      !(!Variant_CheckForP1957R2<bool>::value &&
        bsl::is_same<bool, typename bsl::remove_cvref<t_DEST>::type>::value &&
        !bsl::is_same<bool,
                      typename bsl::remove_cvref<t_SOURCE>::type>::value)> {
};
 
                       // =============================
                       // struct Variant_OverloadSetImp
                       // =============================
 
/// This component-private metafunction computes an overload set consisting
/// of one function, named `candidate`, for each type in (template
/// parameters) `t_HEAD, t_TAIL...`, having one parameter of that type.
/// Each such function participates in overload resolution only when
/// `std::declval<t_SRC>()` is convertible to the alternative without
/// narrowing, and returns `bsl::integral_constant<t_INDEX + i>`, where `i`
/// is the zero-based index of the corresponding alternative.  Note that a
/// type that occurs multiple times in `t_HEAD, t_TAIL...` (possibly with
/// varying cv-qualifications) will only result in the generation of a
/// single candidate.  This implementation relies on expression SFINAE,
/// `decltype`, `std::declval`, and P1957R2; since these features are not
/// available in C++03, the C++03 version requires an exact match modulo
/// cv-qualification.
template <class t_SRC, size_t t_INDEX, class t_HEAD, class... t_TAIL>
struct Variant_OverloadSetImp
: Variant_OverloadSetImp<t_SRC, t_INDEX + 1, t_TAIL...> {
 
    using Variant_OverloadSetImp<t_SRC, t_INDEX + 1, t_TAIL...>::candidate;
 
    template <class t_DEST = t_HEAD>
    static typename bsl::enable_if<
        Variant_ConvertsWithoutNarrowing<t_DEST, t_SRC>::value,
        bsl::integral_constant<size_t, t_INDEX> >::type candidate(t_HEAD);
};
template <class t_SRC, size_t t_INDEX, class t_HEAD>
struct Variant_OverloadSetImp<t_SRC, t_INDEX, t_HEAD> {
    template <class t_DEST = t_HEAD>
    static typename bsl::enable_if<
        Variant_ConvertsWithoutNarrowing<t_DEST, t_SRC>::value,
        bsl::integral_constant<size_t, t_INDEX> >::type candidate(t_HEAD);
};
 
/// This component-private metafunction provides a member typedef `Index`
/// representing the value that should be computed by
/// `Variant_ConvertIndex`.  The primary template is instantiated when the
/// partial specialization below is not viable because no viable alternative
/// exists for the conversion or because the best match is not "unique" (see
/// the documentation of `Variant_ConvertIndex` for an explanation).
template <class t_SRC, class t_VARIANT, class = void>
struct Variant_OverloadHelper {
 
    typedef bsl::integral_constant<size_t, bsl::variant_npos> Index;
};
 
/// This partial specialization is used when a "unique" best match is found
/// for converting `std::declval<t_SRC>()` to one of (template parameters)
/// `t_HEAD, t_TAIL...`.
template <class t_SRC, class t_HEAD, class... t_TAIL>
struct Variant_OverloadHelper<
    t_SRC,
    bsl::variant<t_HEAD, t_TAIL...>,
    bsl::void_t<decltype(Variant_OverloadSetImp<t_SRC, 0, t_HEAD, t_TAIL...>::
                             candidate(std::declval<t_SRC>()))> > {
    typedef decltype(
        Variant_OverloadSetImp<t_SRC, 0, t_HEAD, t_TAIL...>::candidate(
            std::declval<t_SRC>())) Index;
};
 
/// This component-private metafunction computes the index of the
/// alternative in (template parameter) `t_VARIANT` that is the "unique"
/// best match for conversion from `std::declval<t_TYPE>()`, or
/// `bsl::variant_npos` if there is no such alternative.  An alternative
/// that occurs multiple times in `t_VARIANT` (possibly with varying
/// cv-qualifications) is considered to occur only once; thus, if all
/// alternatives that are tied for the best match are the same type
/// (possibly with varying cv-qualifications), the result is the lowest
/// index at which that type (with any cv-qualification) occurs.
template <class t_TYPE, class t_VARIANT>
struct Variant_ConvertIndex
: Variant_OverloadHelper<t_TYPE, t_VARIANT>::Index {
};
 
#else  // BSL_VARIANT_FULL_IMPLEMENTATION
 
#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
// {{{ BEGIN GENERATED CODE
// Command line: sim_cpp11_features.pl bslstl_variant.h
#ifndef BSLSTL_VARIANT_VARIADIC_LIMIT
#define BSLSTL_VARIANT_VARIADIC_LIMIT 18
#endif
#ifndef BSLSTL_VARIANT_VARIADIC_LIMIT_G
#define BSLSTL_VARIANT_VARIADIC_LIMIT_G BSLSTL_VARIANT_VARIADIC_LIMIT
#endif
template <size_t t_INDEX,
          class t_TYPE,
          class t_HEAD = BSLSTL_VARIANT_NOT_A_TYPE
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 0
        , class t_TAIL_0 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 1
        , class t_TAIL_1 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 2
        , class t_TAIL_2 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 3
        , class t_TAIL_3 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 4
        , class t_TAIL_4 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 5
        , class t_TAIL_5 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 6
        , class t_TAIL_6 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 7
        , class t_TAIL_7 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 8
        , class t_TAIL_8 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 9
        , class t_TAIL_9 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 10
        , class t_TAIL_10 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 11
        , class t_TAIL_11 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 12
        , class t_TAIL_12 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 13
        , class t_TAIL_13 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 14
        , class t_TAIL_14 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 15
        , class t_TAIL_15 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 16
        , class t_TAIL_16 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 17
        , class t_TAIL_17 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 17
        , class = BSLS_COMPILERFEATURES_NILT>
struct Variant_ConvertToIndexImpl;
 
 
template <size_t t_INDEX, class t_TYPE>
struct Variant_ConvertToIndexImpl<t_INDEX, t_TYPE, BSLSTL_VARIANT_NOT_A_TYPE>
: bsl::integral_constant<size_t, bsl::variant_npos> {
};
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 0
template <size_t t_INDEX, class t_TYPE, class t_HEAD>
struct Variant_ConvertToIndexImpl<t_INDEX, t_TYPE, t_HEAD>
: bsl::conditional<
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_ConvertToIndexImpl<t_INDEX + 1, t_TYPE> >::type {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 1
template <size_t t_INDEX, class t_TYPE, class t_HEAD, class t_TAIL_01>
struct Variant_ConvertToIndexImpl<t_INDEX, t_TYPE, t_HEAD, t_TAIL_01>
: bsl::conditional<
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_ConvertToIndexImpl<t_INDEX + 1, t_TYPE, t_TAIL_01> >::type {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 2
template <size_t t_INDEX, class t_TYPE, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02>
struct Variant_ConvertToIndexImpl<t_INDEX, t_TYPE, t_HEAD, t_TAIL_01,
                                                           t_TAIL_02>
: bsl::conditional<
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_ConvertToIndexImpl<t_INDEX + 1, t_TYPE, t_TAIL_01,
                                                      t_TAIL_02> >::type {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 3
template <size_t t_INDEX, class t_TYPE, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03>
struct Variant_ConvertToIndexImpl<t_INDEX, t_TYPE, t_HEAD, t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03>
: bsl::conditional<
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_ConvertToIndexImpl<t_INDEX + 1, t_TYPE, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03> >::type {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 4
template <size_t t_INDEX, class t_TYPE, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04>
struct Variant_ConvertToIndexImpl<t_INDEX, t_TYPE, t_HEAD, t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04>
: bsl::conditional<
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_ConvertToIndexImpl<t_INDEX + 1, t_TYPE, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04> >::type {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 5
template <size_t t_INDEX, class t_TYPE, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05>
struct Variant_ConvertToIndexImpl<t_INDEX, t_TYPE, t_HEAD, t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05>
: bsl::conditional<
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_ConvertToIndexImpl<t_INDEX + 1, t_TYPE, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05> >::type {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 6
template <size_t t_INDEX, class t_TYPE, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06>
struct Variant_ConvertToIndexImpl<t_INDEX, t_TYPE, t_HEAD, t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06>
: bsl::conditional<
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_ConvertToIndexImpl<t_INDEX + 1, t_TYPE, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06> >::type {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 7
template <size_t t_INDEX, class t_TYPE, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07>
struct Variant_ConvertToIndexImpl<t_INDEX, t_TYPE, t_HEAD, t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07>
: bsl::conditional<
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_ConvertToIndexImpl<t_INDEX + 1, t_TYPE, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07> >::type {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 8
template <size_t t_INDEX, class t_TYPE, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08>
struct Variant_ConvertToIndexImpl<t_INDEX, t_TYPE, t_HEAD, t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08>
: bsl::conditional<
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_ConvertToIndexImpl<t_INDEX + 1, t_TYPE, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08> >::type {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 9
template <size_t t_INDEX, class t_TYPE, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09>
struct Variant_ConvertToIndexImpl<t_INDEX, t_TYPE, t_HEAD, t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09>
: bsl::conditional<
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_ConvertToIndexImpl<t_INDEX + 1, t_TYPE, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09> >::type {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 10
template <size_t t_INDEX, class t_TYPE, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09,
                                                      class t_TAIL_10>
struct Variant_ConvertToIndexImpl<t_INDEX, t_TYPE, t_HEAD, t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10>
: bsl::conditional<
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_ConvertToIndexImpl<t_INDEX + 1, t_TYPE, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10> >::type {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 11
template <size_t t_INDEX, class t_TYPE, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09,
                                                      class t_TAIL_10,
                                                      class t_TAIL_11>
struct Variant_ConvertToIndexImpl<t_INDEX, t_TYPE, t_HEAD, t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11>
: bsl::conditional<
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_ConvertToIndexImpl<t_INDEX + 1, t_TYPE, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11> >::type {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 12
template <size_t t_INDEX, class t_TYPE, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09,
                                                      class t_TAIL_10,
                                                      class t_TAIL_11,
                                                      class t_TAIL_12>
struct Variant_ConvertToIndexImpl<t_INDEX, t_TYPE, t_HEAD, t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12>
: bsl::conditional<
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_ConvertToIndexImpl<t_INDEX + 1, t_TYPE, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12> >::type {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 13
template <size_t t_INDEX, class t_TYPE, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09,
                                                      class t_TAIL_10,
                                                      class t_TAIL_11,
                                                      class t_TAIL_12,
                                                      class t_TAIL_13>
struct Variant_ConvertToIndexImpl<t_INDEX, t_TYPE, t_HEAD, t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13>
: bsl::conditional<
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_ConvertToIndexImpl<t_INDEX + 1, t_TYPE, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13> >::type {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 14
template <size_t t_INDEX, class t_TYPE, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09,
                                                      class t_TAIL_10,
                                                      class t_TAIL_11,
                                                      class t_TAIL_12,
                                                      class t_TAIL_13,
                                                      class t_TAIL_14>
struct Variant_ConvertToIndexImpl<t_INDEX, t_TYPE, t_HEAD, t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14>
: bsl::conditional<
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_ConvertToIndexImpl<t_INDEX + 1, t_TYPE, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14> >::type {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 15
template <size_t t_INDEX, class t_TYPE, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09,
                                                      class t_TAIL_10,
                                                      class t_TAIL_11,
                                                      class t_TAIL_12,
                                                      class t_TAIL_13,
                                                      class t_TAIL_14,
                                                      class t_TAIL_15>
struct Variant_ConvertToIndexImpl<t_INDEX, t_TYPE, t_HEAD, t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14,
                                                           t_TAIL_15>
: bsl::conditional<
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_ConvertToIndexImpl<t_INDEX + 1, t_TYPE, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15> >::type {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 16
template <size_t t_INDEX, class t_TYPE, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09,
                                                      class t_TAIL_10,
                                                      class t_TAIL_11,
                                                      class t_TAIL_12,
                                                      class t_TAIL_13,
                                                      class t_TAIL_14,
                                                      class t_TAIL_15,
                                                      class t_TAIL_16>
struct Variant_ConvertToIndexImpl<t_INDEX, t_TYPE, t_HEAD, t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14,
                                                           t_TAIL_15,
                                                           t_TAIL_16>
: bsl::conditional<
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_ConvertToIndexImpl<t_INDEX + 1, t_TYPE, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16> >::type {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 17
template <size_t t_INDEX, class t_TYPE, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09,
                                                      class t_TAIL_10,
                                                      class t_TAIL_11,
                                                      class t_TAIL_12,
                                                      class t_TAIL_13,
                                                      class t_TAIL_14,
                                                      class t_TAIL_15,
                                                      class t_TAIL_16,
                                                      class t_TAIL_17>
struct Variant_ConvertToIndexImpl<t_INDEX, t_TYPE, t_HEAD, t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14,
                                                           t_TAIL_15,
                                                           t_TAIL_16,
                                                           t_TAIL_17>
: bsl::conditional<
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_ConvertToIndexImpl<t_INDEX + 1, t_TYPE, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16,
                                                      t_TAIL_17> >::type {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 18
template <size_t t_INDEX, class t_TYPE, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09,
                                                      class t_TAIL_10,
                                                      class t_TAIL_11,
                                                      class t_TAIL_12,
                                                      class t_TAIL_13,
                                                      class t_TAIL_14,
                                                      class t_TAIL_15,
                                                      class t_TAIL_16,
                                                      class t_TAIL_17,
                                                      class t_TAIL_18>
struct Variant_ConvertToIndexImpl<t_INDEX, t_TYPE, t_HEAD, t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14,
                                                           t_TAIL_15,
                                                           t_TAIL_16,
                                                           t_TAIL_17,
                                                           t_TAIL_18>
: bsl::conditional<
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_ConvertToIndexImpl<t_INDEX + 1, t_TYPE, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16,
                                                      t_TAIL_17,
                                                      t_TAIL_18> >::type {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 18
 
 
template <class t_TYPE, class t_VARIANT>
struct Variant_ConvertIndex;
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 0
template <class t_TYPE, class t_HEAD>
struct Variant_ConvertIndex<t_TYPE, bsl::variant<t_HEAD> >
: Variant_ConvertToIndexImpl<
      0,
      typename bslmf::MovableRefUtil::RemoveReference<t_TYPE>::type,
      t_HEAD> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 1
template <class t_TYPE, class t_HEAD, class t_TAIL_01>
struct Variant_ConvertIndex<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01> >
: Variant_ConvertToIndexImpl<
      0,
      typename bslmf::MovableRefUtil::RemoveReference<t_TYPE>::type,
      t_HEAD,
      t_TAIL_01> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 2
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02>
struct Variant_ConvertIndex<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                         t_TAIL_02> >
: Variant_ConvertToIndexImpl<
      0,
      typename bslmf::MovableRefUtil::RemoveReference<t_TYPE>::type,
      t_HEAD,
      t_TAIL_01,
      t_TAIL_02> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 3
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03>
struct Variant_ConvertIndex<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                         t_TAIL_02,
                                                         t_TAIL_03> >
: Variant_ConvertToIndexImpl<
      0,
      typename bslmf::MovableRefUtil::RemoveReference<t_TYPE>::type,
      t_HEAD,
      t_TAIL_01,
      t_TAIL_02,
      t_TAIL_03> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 4
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04>
struct Variant_ConvertIndex<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                         t_TAIL_02,
                                                         t_TAIL_03,
                                                         t_TAIL_04> >
: Variant_ConvertToIndexImpl<
      0,
      typename bslmf::MovableRefUtil::RemoveReference<t_TYPE>::type,
      t_HEAD,
      t_TAIL_01,
      t_TAIL_02,
      t_TAIL_03,
      t_TAIL_04> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 5
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05>
struct Variant_ConvertIndex<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                         t_TAIL_02,
                                                         t_TAIL_03,
                                                         t_TAIL_04,
                                                         t_TAIL_05> >
: Variant_ConvertToIndexImpl<
      0,
      typename bslmf::MovableRefUtil::RemoveReference<t_TYPE>::type,
      t_HEAD,
      t_TAIL_01,
      t_TAIL_02,
      t_TAIL_03,
      t_TAIL_04,
      t_TAIL_05> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 6
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06>
struct Variant_ConvertIndex<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                         t_TAIL_02,
                                                         t_TAIL_03,
                                                         t_TAIL_04,
                                                         t_TAIL_05,
                                                         t_TAIL_06> >
: Variant_ConvertToIndexImpl<
      0,
      typename bslmf::MovableRefUtil::RemoveReference<t_TYPE>::type,
      t_HEAD,
      t_TAIL_01,
      t_TAIL_02,
      t_TAIL_03,
      t_TAIL_04,
      t_TAIL_05,
      t_TAIL_06> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 7
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07>
struct Variant_ConvertIndex<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                         t_TAIL_02,
                                                         t_TAIL_03,
                                                         t_TAIL_04,
                                                         t_TAIL_05,
                                                         t_TAIL_06,
                                                         t_TAIL_07> >
: Variant_ConvertToIndexImpl<
      0,
      typename bslmf::MovableRefUtil::RemoveReference<t_TYPE>::type,
      t_HEAD,
      t_TAIL_01,
      t_TAIL_02,
      t_TAIL_03,
      t_TAIL_04,
      t_TAIL_05,
      t_TAIL_06,
      t_TAIL_07> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 8
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08>
struct Variant_ConvertIndex<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                         t_TAIL_02,
                                                         t_TAIL_03,
                                                         t_TAIL_04,
                                                         t_TAIL_05,
                                                         t_TAIL_06,
                                                         t_TAIL_07,
                                                         t_TAIL_08> >
: Variant_ConvertToIndexImpl<
      0,
      typename bslmf::MovableRefUtil::RemoveReference<t_TYPE>::type,
      t_HEAD,
      t_TAIL_01,
      t_TAIL_02,
      t_TAIL_03,
      t_TAIL_04,
      t_TAIL_05,
      t_TAIL_06,
      t_TAIL_07,
      t_TAIL_08> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 9
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09>
struct Variant_ConvertIndex<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                         t_TAIL_02,
                                                         t_TAIL_03,
                                                         t_TAIL_04,
                                                         t_TAIL_05,
                                                         t_TAIL_06,
                                                         t_TAIL_07,
                                                         t_TAIL_08,
                                                         t_TAIL_09> >
: Variant_ConvertToIndexImpl<
      0,
      typename bslmf::MovableRefUtil::RemoveReference<t_TYPE>::type,
      t_HEAD,
      t_TAIL_01,
      t_TAIL_02,
      t_TAIL_03,
      t_TAIL_04,
      t_TAIL_05,
      t_TAIL_06,
      t_TAIL_07,
      t_TAIL_08,
      t_TAIL_09> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 10
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10>
struct Variant_ConvertIndex<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                         t_TAIL_02,
                                                         t_TAIL_03,
                                                         t_TAIL_04,
                                                         t_TAIL_05,
                                                         t_TAIL_06,
                                                         t_TAIL_07,
                                                         t_TAIL_08,
                                                         t_TAIL_09,
                                                         t_TAIL_10> >
: Variant_ConvertToIndexImpl<
      0,
      typename bslmf::MovableRefUtil::RemoveReference<t_TYPE>::type,
      t_HEAD,
      t_TAIL_01,
      t_TAIL_02,
      t_TAIL_03,
      t_TAIL_04,
      t_TAIL_05,
      t_TAIL_06,
      t_TAIL_07,
      t_TAIL_08,
      t_TAIL_09,
      t_TAIL_10> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 11
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11>
struct Variant_ConvertIndex<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                         t_TAIL_02,
                                                         t_TAIL_03,
                                                         t_TAIL_04,
                                                         t_TAIL_05,
                                                         t_TAIL_06,
                                                         t_TAIL_07,
                                                         t_TAIL_08,
                                                         t_TAIL_09,
                                                         t_TAIL_10,
                                                         t_TAIL_11> >
: Variant_ConvertToIndexImpl<
      0,
      typename bslmf::MovableRefUtil::RemoveReference<t_TYPE>::type,
      t_HEAD,
      t_TAIL_01,
      t_TAIL_02,
      t_TAIL_03,
      t_TAIL_04,
      t_TAIL_05,
      t_TAIL_06,
      t_TAIL_07,
      t_TAIL_08,
      t_TAIL_09,
      t_TAIL_10,
      t_TAIL_11> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 12
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12>
struct Variant_ConvertIndex<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                         t_TAIL_02,
                                                         t_TAIL_03,
                                                         t_TAIL_04,
                                                         t_TAIL_05,
                                                         t_TAIL_06,
                                                         t_TAIL_07,
                                                         t_TAIL_08,
                                                         t_TAIL_09,
                                                         t_TAIL_10,
                                                         t_TAIL_11,
                                                         t_TAIL_12> >
: Variant_ConvertToIndexImpl<
      0,
      typename bslmf::MovableRefUtil::RemoveReference<t_TYPE>::type,
      t_HEAD,
      t_TAIL_01,
      t_TAIL_02,
      t_TAIL_03,
      t_TAIL_04,
      t_TAIL_05,
      t_TAIL_06,
      t_TAIL_07,
      t_TAIL_08,
      t_TAIL_09,
      t_TAIL_10,
      t_TAIL_11,
      t_TAIL_12> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 13
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13>
struct Variant_ConvertIndex<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                         t_TAIL_02,
                                                         t_TAIL_03,
                                                         t_TAIL_04,
                                                         t_TAIL_05,
                                                         t_TAIL_06,
                                                         t_TAIL_07,
                                                         t_TAIL_08,
                                                         t_TAIL_09,
                                                         t_TAIL_10,
                                                         t_TAIL_11,
                                                         t_TAIL_12,
                                                         t_TAIL_13> >
: Variant_ConvertToIndexImpl<
      0,
      typename bslmf::MovableRefUtil::RemoveReference<t_TYPE>::type,
      t_HEAD,
      t_TAIL_01,
      t_TAIL_02,
      t_TAIL_03,
      t_TAIL_04,
      t_TAIL_05,
      t_TAIL_06,
      t_TAIL_07,
      t_TAIL_08,
      t_TAIL_09,
      t_TAIL_10,
      t_TAIL_11,
      t_TAIL_12,
      t_TAIL_13> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 14
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14>
struct Variant_ConvertIndex<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                         t_TAIL_02,
                                                         t_TAIL_03,
                                                         t_TAIL_04,
                                                         t_TAIL_05,
                                                         t_TAIL_06,
                                                         t_TAIL_07,
                                                         t_TAIL_08,
                                                         t_TAIL_09,
                                                         t_TAIL_10,
                                                         t_TAIL_11,
                                                         t_TAIL_12,
                                                         t_TAIL_13,
                                                         t_TAIL_14> >
: Variant_ConvertToIndexImpl<
      0,
      typename bslmf::MovableRefUtil::RemoveReference<t_TYPE>::type,
      t_HEAD,
      t_TAIL_01,
      t_TAIL_02,
      t_TAIL_03,
      t_TAIL_04,
      t_TAIL_05,
      t_TAIL_06,
      t_TAIL_07,
      t_TAIL_08,
      t_TAIL_09,
      t_TAIL_10,
      t_TAIL_11,
      t_TAIL_12,
      t_TAIL_13,
      t_TAIL_14> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 15
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14,
                                      class t_TAIL_15>
struct Variant_ConvertIndex<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                         t_TAIL_02,
                                                         t_TAIL_03,
                                                         t_TAIL_04,
                                                         t_TAIL_05,
                                                         t_TAIL_06,
                                                         t_TAIL_07,
                                                         t_TAIL_08,
                                                         t_TAIL_09,
                                                         t_TAIL_10,
                                                         t_TAIL_11,
                                                         t_TAIL_12,
                                                         t_TAIL_13,
                                                         t_TAIL_14,
                                                         t_TAIL_15> >
: Variant_ConvertToIndexImpl<
      0,
      typename bslmf::MovableRefUtil::RemoveReference<t_TYPE>::type,
      t_HEAD,
      t_TAIL_01,
      t_TAIL_02,
      t_TAIL_03,
      t_TAIL_04,
      t_TAIL_05,
      t_TAIL_06,
      t_TAIL_07,
      t_TAIL_08,
      t_TAIL_09,
      t_TAIL_10,
      t_TAIL_11,
      t_TAIL_12,
      t_TAIL_13,
      t_TAIL_14,
      t_TAIL_15> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 16
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14,
                                      class t_TAIL_15,
                                      class t_TAIL_16>
struct Variant_ConvertIndex<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                         t_TAIL_02,
                                                         t_TAIL_03,
                                                         t_TAIL_04,
                                                         t_TAIL_05,
                                                         t_TAIL_06,
                                                         t_TAIL_07,
                                                         t_TAIL_08,
                                                         t_TAIL_09,
                                                         t_TAIL_10,
                                                         t_TAIL_11,
                                                         t_TAIL_12,
                                                         t_TAIL_13,
                                                         t_TAIL_14,
                                                         t_TAIL_15,
                                                         t_TAIL_16> >
: Variant_ConvertToIndexImpl<
      0,
      typename bslmf::MovableRefUtil::RemoveReference<t_TYPE>::type,
      t_HEAD,
      t_TAIL_01,
      t_TAIL_02,
      t_TAIL_03,
      t_TAIL_04,
      t_TAIL_05,
      t_TAIL_06,
      t_TAIL_07,
      t_TAIL_08,
      t_TAIL_09,
      t_TAIL_10,
      t_TAIL_11,
      t_TAIL_12,
      t_TAIL_13,
      t_TAIL_14,
      t_TAIL_15,
      t_TAIL_16> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 17
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14,
                                      class t_TAIL_15,
                                      class t_TAIL_16,
                                      class t_TAIL_17>
struct Variant_ConvertIndex<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                         t_TAIL_02,
                                                         t_TAIL_03,
                                                         t_TAIL_04,
                                                         t_TAIL_05,
                                                         t_TAIL_06,
                                                         t_TAIL_07,
                                                         t_TAIL_08,
                                                         t_TAIL_09,
                                                         t_TAIL_10,
                                                         t_TAIL_11,
                                                         t_TAIL_12,
                                                         t_TAIL_13,
                                                         t_TAIL_14,
                                                         t_TAIL_15,
                                                         t_TAIL_16,
                                                         t_TAIL_17> >
: Variant_ConvertToIndexImpl<
      0,
      typename bslmf::MovableRefUtil::RemoveReference<t_TYPE>::type,
      t_HEAD,
      t_TAIL_01,
      t_TAIL_02,
      t_TAIL_03,
      t_TAIL_04,
      t_TAIL_05,
      t_TAIL_06,
      t_TAIL_07,
      t_TAIL_08,
      t_TAIL_09,
      t_TAIL_10,
      t_TAIL_11,
      t_TAIL_12,
      t_TAIL_13,
      t_TAIL_14,
      t_TAIL_15,
      t_TAIL_16,
      t_TAIL_17> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 18
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14,
                                      class t_TAIL_15,
                                      class t_TAIL_16,
                                      class t_TAIL_17,
                                      class t_TAIL_18>
struct Variant_ConvertIndex<t_TYPE, bsl::variant<t_HEAD, t_TAIL_01,
                                                         t_TAIL_02,
                                                         t_TAIL_03,
                                                         t_TAIL_04,
                                                         t_TAIL_05,
                                                         t_TAIL_06,
                                                         t_TAIL_07,
                                                         t_TAIL_08,
                                                         t_TAIL_09,
                                                         t_TAIL_10,
                                                         t_TAIL_11,
                                                         t_TAIL_12,
                                                         t_TAIL_13,
                                                         t_TAIL_14,
                                                         t_TAIL_15,
                                                         t_TAIL_16,
                                                         t_TAIL_17,
                                                         t_TAIL_18> >
: Variant_ConvertToIndexImpl<
      0,
      typename bslmf::MovableRefUtil::RemoveReference<t_TYPE>::type,
      t_HEAD,
      t_TAIL_01,
      t_TAIL_02,
      t_TAIL_03,
      t_TAIL_04,
      t_TAIL_05,
      t_TAIL_06,
      t_TAIL_07,
      t_TAIL_08,
      t_TAIL_09,
      t_TAIL_10,
      t_TAIL_11,
      t_TAIL_12,
      t_TAIL_13,
      t_TAIL_14,
      t_TAIL_15,
      t_TAIL_16,
      t_TAIL_17,
      t_TAIL_18> {
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 18
 
#else
// The generated code below is a workaround for the absence of perfect
// forwarding in some compilers.
template <size_t t_INDEX,
          class t_TYPE,
          class t_HEAD = BSLSTL_VARIANT_NOT_A_TYPE,
          class... t_TAIL>
struct Variant_ConvertToIndexImpl;
 
template <size_t t_INDEX, class t_TYPE>
struct Variant_ConvertToIndexImpl<t_INDEX, t_TYPE, BSLSTL_VARIANT_NOT_A_TYPE>
: bsl::integral_constant<size_t, bsl::variant_npos> {
};
template <size_t t_INDEX, class t_TYPE, class t_HEAD, class... t_TAIL>
struct Variant_ConvertToIndexImpl<t_INDEX, t_TYPE, t_HEAD, t_TAIL...>
: bsl::conditional<
      bsl::is_same<typename bsl::remove_cv<t_TYPE>::type,
                   typename bsl::remove_cv<t_HEAD>::type>::value,
      bsl::integral_constant<size_t, t_INDEX>,
      Variant_ConvertToIndexImpl<t_INDEX + 1, t_TYPE, t_TAIL...> >::type {
};
 
template <class t_TYPE, class t_VARIANT>
struct Variant_ConvertIndex;
 
template <class t_TYPE, class t_HEAD, class... t_TAIL>
struct Variant_ConvertIndex<t_TYPE, bsl::variant<t_HEAD, t_TAIL...> >
: Variant_ConvertToIndexImpl<
      0,
      typename bslmf::MovableRefUtil::RemoveReference<t_TYPE>::type,
      t_HEAD,
      t_TAIL...> {
};
 
// }}} END GENERATED CODE
#endif
#endif  // BSL_VARIANT_FULL_IMPLEMENTATION
 
/// This component-private metafunction is derived from `bsl::true_type` if
/// there is a unique best match alternative in (template parameter)
/// `t_VARIANT` for 'std::declval<t_TYPE>() and that alternative is
/// constructible from `std::declval<t_TYPE>(), and `bsl::false_type'
/// otherwise.
template <class t_VARIANT,
          class t_TYPE,
          size_t t_INDEX = BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, t_VARIANT)>
struct Variant_IsAlternativeConstructibleFrom
: bsl::integral_constant<
      bool,
      Variant_IsConstructible<
          typename bsl::variant_alternative<t_INDEX, t_VARIANT>::type,
          t_TYPE>::value &&
          Variant_HasUniqueCVType<BSLSTL_VARIANT_CONVERT_TYPE_OF(t_TYPE,
                                                                 t_VARIANT),
                                  t_VARIANT>::value> {
};
 
template <class t_VARIANT, class t_TYPE>
struct Variant_IsAlternativeConstructibleFrom<t_VARIANT,
                                              t_TYPE,
                                              bsl::variant_npos>
: bsl::false_type {
};
 
/// This component-private metafunction is derived from `bsl::true_type` if
/// there is a unique best match alternative in (template parameter)
/// `t_VARIANT` for `std::declval<t_TYPE>()` and that alternative is both
/// constructible and assignable from `std::declval<t_TYPE>()`, and
/// `bsl::false_type` otherwise.
template <class t_VARIANT,
          class t_TYPE,
          size_t t_INDEX = BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, t_VARIANT)>
struct Variant_isAlternativeAssignableFrom
: bsl::integral_constant<
      bool,
      Variant_IsAssignable<
          typename bsl::variant_alternative<t_INDEX, t_VARIANT>::type&,
          t_TYPE>::value &&
          Variant_HasUniqueCVType<BSLSTL_VARIANT_CONVERT_TYPE_OF(t_TYPE,
                                                                 t_VARIANT),
                                  t_VARIANT>::value> {
};
 
template <class t_VARIANT, class t_TYPE>
struct Variant_isAlternativeAssignableFrom<t_VARIANT,
                                           t_TYPE,
                                           bsl::variant_npos>
: bsl::false_type {
};
 
/// This component-private metafunction declares a member `type` that is an
/// alias to the `std::variant` type corresponding to `t_TYPE` if one
/// exists, and `void` otherwise.
template <class t_TYPE>
struct Variant_CorrespondingStdVariant {
    typedef void type;
};
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
template <class t_HEAD, class... t_TAIL>
struct Variant_CorrespondingStdVariant<bsl::variant<t_HEAD, t_TAIL...>> {
    typedef std::variant<t_HEAD, t_TAIL...> type;
};
#endif  // BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
 
/// This component-private metafunction is derived from `bsl::true_type` if
/// (template parameter) `t_TYPE` is neither a tag type, nor the type
/// (template parameter) `t_VARIANT` (modulo cv-qualification), nor the
/// corresponding (possibly cv-qualified) `std::variant` type, there is a
/// unique best match alternative in `t_VARIANT` for
/// `std::declval<t_TYPE>()`, and that alternative is constructible from
/// `std::declval<t_TYPE>()`; otherwise, this metafunction is derived from
/// `bsl::false_type`.
template <class t_VARIANT, class t_TYPE>
struct Variant_ConstructsFromType
: bsl::integral_constant<
      bool,
      !bsl::is_same<typename bsl::remove_cvref<t_TYPE>::type,
                    t_VARIANT>::value &&
          !Variant_IsTag<typename bsl::remove_cvref<t_TYPE>::type>::value &&
          !bsl::is_same<
              typename Variant_CorrespondingStdVariant<t_VARIANT>::type,
              typename bsl::remove_cvref<t_TYPE>::type>::value &&
          Variant_IsAlternativeConstructibleFrom<t_VARIANT, t_TYPE>::value> {
};
 
/// This component-private metafunction is derived from `bsl::true_type` if
/// (template parameter) `t_TYPE` is neither a tag type nor the type
/// (template parameter) `t_VARIANT` (modulo cv-qualification), there is a
/// unique best match alternative in `t_VARIANT` for
/// `std::declval<t_TYPE>()`, and that alternative is constructible and
/// assignable from `std::declval<t_TYPE>()`; otherwise, this metafunction
/// is derived from `bsl::false_type`.
template <class t_VARIANT, class t_TYPE>
struct Variant_AssignsFromType
: bsl::integral_constant<
      bool,
      !bsl::is_same<typename bsl::remove_cvref<t_TYPE>::type,
                    t_VARIANT>::value &&
          Variant_IsAlternativeConstructibleFrom<t_VARIANT, t_TYPE>::value &&
          Variant_isAlternativeAssignableFrom<t_VARIANT, t_TYPE>::value> {
};
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
template <class t_VARIANT, class t_STD_VARIANT>
constexpr bool variant_constructsFromStd =
    // This component-private constexpr variable template is 'true' if
    // 't_VARIANT' is a specialization of 'bsl::variant', and 't_STD_VARIANT'
    // is the 'std::variant' type (possibly with added cvref-qualification)
    // that has the same sequence of alternatives, and each alternative of
    // 't_VARIANT' is constructible from the corresponding alternative of
    // 't_STD_VARIANT' (with cv-qualification and value category matching that
    // of 't_STD_VARIANT').  Note that we use 'bsl::conjunction_v' for its
    // short-circuiting properties: if 't_STD_VARIANT' isn't a 'std::variant'
    // (for example, if it's a 'bsl::variant') we avoid recursing into the
    // constraints of 'bsl::variant'.
  bsl::conjunction_v<
      bsl::is_same<typename Variant_CorrespondingStdVariant<t_VARIANT>::type,
                   bsl::remove_cvref_t<t_STD_VARIANT>>,
      std::is_constructible<bsl::remove_cvref_t<t_STD_VARIANT>,
                            t_STD_VARIANT>>;
#endif  // BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
// The following component-private machinery allows for conditionally deleting
// special member functions.
 
/// This component-private class has deleted copy constructor if (template
/// parameter) `t_ISCOPYCONSTRUCTIBLE` is `false`.  All other special member
/// functions are defaulted.
template <bool t_ISCOPYCONSTRUCTIBLE>
struct Variant_CopyConstructorBase {
};
template <>
struct Variant_CopyConstructorBase<false> {
    Variant_CopyConstructorBase()                                   = default;
    Variant_CopyConstructorBase(const Variant_CopyConstructorBase&) = delete;
    Variant_CopyConstructorBase(Variant_CopyConstructorBase&&)      = default;
    Variant_CopyConstructorBase&
    operator=(const Variant_CopyConstructorBase&) = default;
    Variant_CopyConstructorBase&
    operator=(Variant_CopyConstructorBase&&) = default;
};
 
/// This component-private class has deleted move constructor if (template
/// parameter) `t_ISMOVECONSTRUCTIBLE` is `false`.  All other special member
/// functions are defaulted.
template <bool t_ISCOPYCONSTRUCTIBLE, bool t_ISMOVECONSTRUCTIBLE>
struct Variant_MoveConstructorBase
: Variant_CopyConstructorBase<t_ISCOPYCONSTRUCTIBLE> {
};
template <bool t_ISCOPYCONSTRUCTIBLE>
struct Variant_MoveConstructorBase<t_ISCOPYCONSTRUCTIBLE, false>
: Variant_CopyConstructorBase<t_ISCOPYCONSTRUCTIBLE> {
    Variant_MoveConstructorBase()                                   = default;
    Variant_MoveConstructorBase(const Variant_MoveConstructorBase&) = default;
    Variant_MoveConstructorBase(Variant_MoveConstructorBase&&)      = delete;
    Variant_MoveConstructorBase&
    operator=(const Variant_MoveConstructorBase&) = default;
    Variant_MoveConstructorBase&
    operator=(Variant_MoveConstructorBase&&) = default;
};
 
/// This component-private class has deleted copy assignment operator if
/// (template parameter) `t_ISCOPYASSIGNABLE` is `false`.  All other special
/// member functions are defaulted.
template <bool t_ISCOPYCONSTRUCTIBLE,
          bool t_ISMOVECONSTRUCTIBLE,
          bool t_ISCOPYASSIGNABLE>
struct Variant_CopyAssignBase
: Variant_MoveConstructorBase<t_ISCOPYCONSTRUCTIBLE, t_ISMOVECONSTRUCTIBLE> {
};
template <bool t_ISCOPYCONSTRUCTIBLE, bool t_ISMOVECONSTRUCTIBLE>
struct Variant_CopyAssignBase<t_ISCOPYCONSTRUCTIBLE,
                              t_ISMOVECONSTRUCTIBLE,
                              false>
: Variant_MoveConstructorBase<t_ISCOPYCONSTRUCTIBLE, t_ISMOVECONSTRUCTIBLE> {
    Variant_CopyAssignBase()                                         = default;
    Variant_CopyAssignBase(const Variant_CopyAssignBase&)            = default;
    Variant_CopyAssignBase(Variant_CopyAssignBase&&)                 = default;
    Variant_CopyAssignBase& operator=(const Variant_CopyAssignBase&) = delete;
    Variant_CopyAssignBase& operator=(Variant_CopyAssignBase&&)      = default;
};
 
/// This component-private class has deleted move assignment operator if
/// (template parameter) `t_ISMOVEASSIGNABLE` is `false`.  All other special
/// member functions are defaulted.
template <bool t_ISCOPYCONSTRUCTIBLE,
          bool t_ISMOVECONSTRUCTIBLE,
          bool t_ISCOPYASSIGNABLE,
          bool t_ISMOVEASSIGNABLE>
struct Variant_MoveAssignBase : Variant_CopyAssignBase<t_ISCOPYCONSTRUCTIBLE,
                                                       t_ISMOVECONSTRUCTIBLE,
                                                       t_ISCOPYASSIGNABLE> {
};
template <bool t_ISCOPYCONSTRUCTIBLE,
          bool t_ISMOVECONSTRUCTIBLE,
          bool t_ISCOPYASSIGNABLE>
struct Variant_MoveAssignBase<t_ISCOPYCONSTRUCTIBLE,
                              t_ISMOVECONSTRUCTIBLE,
                              t_ISCOPYASSIGNABLE,
                              false>
: Variant_CopyAssignBase<t_ISCOPYCONSTRUCTIBLE,
                         t_ISMOVECONSTRUCTIBLE,
                         t_ISCOPYASSIGNABLE> {
    Variant_MoveAssignBase()                                         = default;
    Variant_MoveAssignBase(const Variant_MoveAssignBase&)            = default;
    Variant_MoveAssignBase(Variant_MoveAssignBase&&)                 = default;
    Variant_MoveAssignBase& operator=(const Variant_MoveAssignBase&) = default;
    Variant_MoveAssignBase& operator=(Variant_MoveAssignBase&&)      = delete;
};
 
/// This component-private class has special member functions that are
/// either deleted or defaulted according to the specified template
/// parameters.
template <bool t_ISCOPYCONSTRUCTIBLE,
          bool t_ISMOVECONSTRUCTIBLE,
          bool t_ISCOPYASSIGNABLE,
          bool t_ISMOVEASSIGNABLE>
struct Variant_SMFBase : Variant_MoveAssignBase<t_ISCOPYCONSTRUCTIBLE,
                                                t_ISMOVECONSTRUCTIBLE,
                                                t_ISCOPYASSIGNABLE,
                                                t_ISMOVEASSIGNABLE> {
};
 
/// This component-private metafunction is derived from `bsl::true_type` if
/// all template parameters are copy constructible, and `bsl::false_type`
/// otherwise.
template <class t_HEAD, class... t_TAIL>
struct Variant_IsCopyConstructibleAll
: bsl::integral_constant<
      bool,
      std::is_copy_constructible<t_HEAD>::value &&
          Variant_IsCopyConstructibleAll<t_TAIL...>::value> {
};
 
template <class t_HEAD>
struct Variant_IsCopyConstructibleAll<t_HEAD>
: std::is_copy_constructible<t_HEAD> {
};
 
/// This component-private metafunction is derived from `bsl::true_type` if
/// all template parameters are move constructible, and `bsl::false_type`
/// otherwise.
template <class t_HEAD, class... t_TAIL>
struct Variant_IsMoveConstructibleAll
: bsl::integral_constant<
      bool,
      std::is_move_constructible<t_HEAD>::value &&
          Variant_IsMoveConstructibleAll<t_TAIL...>::value> {
};
 
template <class t_HEAD>
struct Variant_IsMoveConstructibleAll<t_HEAD>
: std::is_move_constructible<t_HEAD> {
};
 
/// This component-private metafunction is derived from `bsl::true_type` if
/// all template parameters are copy assignable, and `bsl::false_type`
/// otherwise.
template <class t_HEAD, class... t_TAIL>
struct Variant_IsCopyAssignableAll
: bsl::integral_constant<bool,
                         std::is_copy_assignable<t_HEAD>::value &&
                             Variant_IsCopyAssignableAll<t_TAIL...>::value> {
};
 
template <class t_HEAD>
struct Variant_IsCopyAssignableAll<t_HEAD> : std::is_copy_assignable<t_HEAD> {
};
 
/// This component-private metafunction is derived from `bsl::true_type` if
/// all template parameters are move assignable, and `bsl::false_type`
/// otherwise.
template <class t_HEAD, class... t_TAIL>
struct Variant_IsMoveAssignableAll
: bsl::integral_constant<bool,
                         std::is_move_assignable<t_HEAD>::value &&
                             Variant_IsMoveAssignableAll<t_TAIL...>::value> {
};
 
template <class t_HEAD>
struct Variant_IsMoveAssignableAll<t_HEAD> : std::is_move_assignable<t_HEAD> {
};
#endif  // BSL_VARIANT_FULL_IMPLEMENTATION
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
template <class t_RET, class t_VISITOR, class t_VARIANT, size_t t_INDEX>
struct Variant_Function {
    /// This component-private function invokes the specified `visitor` with
    /// the active alternative object of the specified `variant` and
    /// implicitly converts the return type to (template parameter) `t_RET`.
    /// The pre-C++17 implementation is limited to invocations of the form
    /// `visitor(variant)`.  The behavior is undefined unless (template
    /// parameter) `t_INDEX` is the index of the active alternative.
    static t_RET functionImpl(t_VISITOR&& visitor, t_VARIANT&& variant)
    {
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
        return std::invoke(
            std::forward<t_VISITOR>(visitor),
            bsl::get<t_INDEX>(std::forward<t_VARIANT>(variant)));
#else
        return std::forward<t_VISITOR>(visitor)(
            bsl::get<t_INDEX>(std::forward<t_VARIANT>(variant)));
#endif
    }
};
 
/// This partial specialization is used when `t_RET` is `void`.  The visitor
/// is invoked and its return value, if any, is ignored.  This partial
/// specialization is necessary because a `void`-returning function cannot
/// contain a `return` statement with a non-`void` operand.
template <class t_VISITOR, class t_VARIANT, size_t t_INDEX>
struct Variant_Function<void, t_VISITOR, t_VARIANT, t_INDEX> {
 
    static void functionImpl(t_VISITOR&& visitor, t_VARIANT&& variant)
    {
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
        std::invoke(std::forward<t_VISITOR>(visitor),
                    bsl::get<t_INDEX>(std::forward<t_VARIANT>(variant)));
#else
        std::forward<t_VISITOR>(visitor)(
            bsl::get<t_INDEX>(std::forward<t_VARIANT>(variant)));
#endif
    }
};
 
template <class t_RET, class t_VISITOR, class t_VARIANT, size_t t_INDEX>
struct Variant_FunctionId {
    /// This component-private function invokes the specified `visitor` with
    /// a `bsl::in_place_index_t` tag representing the value of (template
    /// parameter) `t_INDEX` and the active alternative object of the
    /// specified `variant`, implicitly converting the return type to
    /// (template parameter) `t_RET`.  The behavior is undefined unless
    /// `t_INDEX` is the index of the active alternative.
    static t_RET functionImpl(t_VISITOR&& visitor, t_VARIANT&& variant)
    {
        return visitor(bsl::in_place_index_t<t_INDEX>(),
                       bsl::get<t_INDEX>(std::forward<t_VARIANT>(variant)));
    }
};
 
/// This component-private struct computes an array in which element `i` is
/// a pointer to
/// `Variant_Function<t_RET, t_VISITOR, t_VARIANT, i>::functionImpl`,
/// defined above as a function that invokes a `t_VISITOR` with alternative
/// `i` of `t_VARIANT` and implicitly converts the return type to `t_RET`.
template <class t_RET, class t_VISITOR, class t_VARIANT, class t_DUMMY>
struct Variant_VTable;
 
/// In order to allow for perfect forwarding, both t_VISITOR and t_VARIANT
/// must be of reference type.  If they are not, something went wrong.
template <class t_RET, class t_VISITOR, class t_VARIANT, size_t... t_INDICES>
struct Variant_VTable<t_RET,
                      t_VISITOR,
                      t_VARIANT,
                      bslmf::IntegerSequence<std::size_t, t_INDICES...> > {
    BSLMF_ASSERT(bsl::is_reference<t_VISITOR>::value);
    BSLMF_ASSERT(bsl::is_reference<t_VARIANT>::value);
 
    typedef t_RET (*FuncPtr)(t_VISITOR, t_VARIANT);
 
    static BSLS_KEYWORD_CONSTEXPR FuncPtr s_map[sizeof...(t_INDICES)] = {
        &(Variant_Function<t_RET, t_VISITOR, t_VARIANT, t_INDICES>::
              functionImpl)...};
};
 
/// This component-private struct computes an array in which element `i` is
/// a pointer to
/// `Variant_FunctionId<t_RET, t_VISITOR, t_VARIANT, i>::functionImpl`,
/// defined above as a function that invokes a `t_VISITOR` with a tag
/// representing `i` and alternative `i` of `t_VARIANT`, implicitly
/// converting the return type to `t_RET`.  Implementation note: The
/// constexpr static maps of pointers defined by `Variant_VTable` and this
/// class have deliberately been defined in two different classes as having
/// them in the same class caused issues with Clang and Microsoft Visual
/// C++.
template <class t_RET, class t_VISITOR, class t_VARIANT, class t_DUMMY>
struct Variant_VTableId;
 
/// In order to allow for perfect forwarding, both t_VISITOR and t_VARIANT
/// must be of reference type.  If they are not, something went wrong.
template <class t_RET, class t_VISITOR, class t_VARIANT, size_t... t_INDICES>
struct Variant_VTableId<t_RET,
                        t_VISITOR,
                        t_VARIANT,
                        bslmf::IntegerSequence<std::size_t, t_INDICES...> > {
    BSLMF_ASSERT(bsl::is_reference<t_VISITOR>::value);
    BSLMF_ASSERT(bsl::is_reference<t_VARIANT>::value);
 
    typedef t_RET (*FuncPtr)(t_VISITOR, t_VARIANT);
 
    static BSLS_KEYWORD_CONSTEXPR FuncPtr s_mapId[sizeof...(t_INDICES)] = {
        &(Variant_FunctionId<t_RET, t_VISITOR, t_VARIANT, t_INDICES>::
              functionImpl)...};
};
 
// inline definitions of component-private function pointer maps
template <class t_RET, class t_VISITOR, class t_VARIANT, size_t... t_INDICES>
BSLS_KEYWORD_CONSTEXPR typename Variant_VTable<
    t_RET,
    t_VISITOR,
    t_VARIANT,
    bslmf::IntegerSequence<std::size_t, t_INDICES...> >::FuncPtr
    Variant_VTable<t_RET,
                   t_VISITOR,
                   t_VARIANT,
                   bslmf::IntegerSequence<std::size_t, t_INDICES...> >::s_map
        [sizeof...(t_INDICES)];
 
template <class t_RET, class t_VISITOR, class t_VARIANT, size_t... t_INDICES>
BSLS_KEYWORD_CONSTEXPR typename Variant_VTableId<
    t_RET,
    t_VISITOR,
    t_VARIANT,
    bslmf::IntegerSequence<std::size_t, t_INDICES...> >::FuncPtr
    Variant_VTableId<t_RET,
                     t_VISITOR,
                     t_VARIANT,
                     bslmf::IntegerSequence<std::size_t, t_INDICES...> >::
        s_mapId[sizeof...(t_INDICES)];
 
#else  // BSL_VARIANT_FULL_IMPLEMENTATION
#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
// {{{ BEGIN GENERATED CODE
// Command line: sim_cpp11_features.pl bslstl_variant.h
#ifndef BSLSTL_VARIANT_VARIADIC_LIMIT
#define BSLSTL_VARIANT_VARIADIC_LIMIT 18
#endif
#ifndef BSLSTL_VARIANT_VARIADIC_LIMIT_H
#define BSLSTL_VARIANT_VARIADIC_LIMIT_H BSLSTL_VARIANT_VARIADIC_LIMIT
#endif
 
template <class t_RET, class t_VISITOR, class t_VARIANT, class t_ALT_TYPE>
struct Variant_Function {
    static t_RET functionImpl(t_VISITOR& visitor, t_VARIANT& variant)
    {
        typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
        return visitor(ImpUtil::unsafeGet<t_ALT_TYPE>(variant));
    }
};
 
template <class t_VISITOR, class t_VARIANT, class t_ALT_TYPE>
struct Variant_Function<void, t_VISITOR, t_VARIANT, t_ALT_TYPE> {
 
    static void functionImpl(t_VISITOR& visitor, t_VARIANT& variant)
    {
        typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
        visitor(ImpUtil::unsafeGet<t_ALT_TYPE>(variant));
    }
};
 
template <class t_RET, class t_VISITOR, class t_VARIANT, class t_ALT_TYPE>
struct Variant_MoveFunction {
    static t_RET functionImpl(t_VISITOR& visitor, t_VARIANT& variant)
    {
        typedef BloombergLP::bslmf::MovableRefUtil   MoveUtil;
        typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
        return visitor(
                      MoveUtil::move(ImpUtil::unsafeGet<t_ALT_TYPE>(variant)));
    }
};
 
template <class t_VISITOR, class t_VARIANT, class t_ALT_TYPE>
struct Variant_MoveFunction<void, t_VISITOR, t_VARIANT, t_ALT_TYPE> {
 
    static void functionImpl(t_VISITOR& visitor, t_VARIANT& variant)
    {
        typedef BloombergLP::bslmf::MovableRefUtil   MoveUtil;
        typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
        visitor(MoveUtil::move(ImpUtil::unsafeGet<t_ALT_TYPE>(variant)));
    }
};
 
template <class t_RET, class t_VISITOR, class t_VARIANT, class t_ALT_TYPE>
struct Variant_FunctionId {
    static t_RET functionImpl(t_VISITOR& visitor, t_VARIANT& variant)
    {
        typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
        static const size_t t_INDEX = BSLSTL_VARIANT_INDEX_OF(
            t_ALT_TYPE, typename bsl::remove_cv<t_VARIANT>::type);
 
        return visitor(bsl::in_place_index_t<t_INDEX>(),
                       ImpUtil::unsafeGet<t_ALT_TYPE>(variant));
    }
};
 
template <class t_RET,
          class t_VISITOR,
          class t_VARIANT
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 0
        , class t_UNUSED_0 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 1
        , class t_UNUSED_1 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 2
        , class t_UNUSED_2 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 3
        , class t_UNUSED_3 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 4
        , class t_UNUSED_4 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 5
        , class t_UNUSED_5 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 6
        , class t_UNUSED_6 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 7
        , class t_UNUSED_7 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 8
        , class t_UNUSED_8 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 9
        , class t_UNUSED_9 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 10
        , class t_UNUSED_10 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 11
        , class t_UNUSED_11 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 12
        , class t_UNUSED_12 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 13
        , class t_UNUSED_13 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 14
        , class t_UNUSED_14 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 15
        , class t_UNUSED_15 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 16
        , class t_UNUSED_16 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 17
        , class t_UNUSED_17 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 17
        , class = BSLS_COMPILERFEATURES_NILT>
struct Variant_VTable;
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 0
template <class t_RET, class t_VISITOR, class t_HEAD>
struct Variant_VTable<t_RET, t_VISITOR, bsl::variant<t_HEAD> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&, bsl::variant<t_HEAD>&);
 
    typedef bsl::variant<t_HEAD> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *moveMap()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl)};
        return s_mapArray;
    }
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 1
template <class t_RET, class t_VISITOR, class t_HEAD, class t_TAIL_01>
struct Variant_VTable<t_RET, t_VISITOR, bsl::variant<t_HEAD, t_TAIL_01> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&, bsl::variant<t_HEAD, t_TAIL_01>&);
 
    typedef bsl::variant<t_HEAD, t_TAIL_01> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *moveMap()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl)};
        return s_mapArray;
    }
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 2
template <class t_RET, class t_VISITOR, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02>
struct Variant_VTable<t_RET, t_VISITOR, bsl::variant<t_HEAD, t_TAIL_01,
                                                             t_TAIL_02> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&, bsl::variant<t_HEAD, t_TAIL_01,
                                                              t_TAIL_02>&);
 
    typedef bsl::variant<t_HEAD, t_TAIL_01,
                                 t_TAIL_02> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *moveMap()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl)};
        return s_mapArray;
    }
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 3
template <class t_RET, class t_VISITOR, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03>
struct Variant_VTable<t_RET, t_VISITOR, bsl::variant<t_HEAD, t_TAIL_01,
                                                             t_TAIL_02,
                                                             t_TAIL_03> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&, bsl::variant<t_HEAD, t_TAIL_01,
                                                              t_TAIL_02,
                                                              t_TAIL_03>&);
 
    typedef bsl::variant<t_HEAD, t_TAIL_01,
                                 t_TAIL_02,
                                 t_TAIL_03> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *moveMap()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl)};
        return s_mapArray;
    }
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 4
template <class t_RET, class t_VISITOR, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04>
struct Variant_VTable<t_RET, t_VISITOR, bsl::variant<t_HEAD, t_TAIL_01,
                                                             t_TAIL_02,
                                                             t_TAIL_03,
                                                             t_TAIL_04> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&, bsl::variant<t_HEAD, t_TAIL_01,
                                                              t_TAIL_02,
                                                              t_TAIL_03,
                                                              t_TAIL_04>&);
 
    typedef bsl::variant<t_HEAD, t_TAIL_01,
                                 t_TAIL_02,
                                 t_TAIL_03,
                                 t_TAIL_04> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *moveMap()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl)};
        return s_mapArray;
    }
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 5
template <class t_RET, class t_VISITOR, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05>
struct Variant_VTable<t_RET, t_VISITOR, bsl::variant<t_HEAD, t_TAIL_01,
                                                             t_TAIL_02,
                                                             t_TAIL_03,
                                                             t_TAIL_04,
                                                             t_TAIL_05> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&, bsl::variant<t_HEAD, t_TAIL_01,
                                                              t_TAIL_02,
                                                              t_TAIL_03,
                                                              t_TAIL_04,
                                                              t_TAIL_05>&);
 
    typedef bsl::variant<t_HEAD, t_TAIL_01,
                                 t_TAIL_02,
                                 t_TAIL_03,
                                 t_TAIL_04,
                                 t_TAIL_05> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *moveMap()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl)};
        return s_mapArray;
    }
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 6
template <class t_RET, class t_VISITOR, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06>
struct Variant_VTable<t_RET, t_VISITOR, bsl::variant<t_HEAD, t_TAIL_01,
                                                             t_TAIL_02,
                                                             t_TAIL_03,
                                                             t_TAIL_04,
                                                             t_TAIL_05,
                                                             t_TAIL_06> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&, bsl::variant<t_HEAD, t_TAIL_01,
                                                              t_TAIL_02,
                                                              t_TAIL_03,
                                                              t_TAIL_04,
                                                              t_TAIL_05,
                                                              t_TAIL_06>&);
 
    typedef bsl::variant<t_HEAD, t_TAIL_01,
                                 t_TAIL_02,
                                 t_TAIL_03,
                                 t_TAIL_04,
                                 t_TAIL_05,
                                 t_TAIL_06> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *moveMap()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl)};
        return s_mapArray;
    }
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 7
template <class t_RET, class t_VISITOR, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07>
struct Variant_VTable<t_RET, t_VISITOR, bsl::variant<t_HEAD, t_TAIL_01,
                                                             t_TAIL_02,
                                                             t_TAIL_03,
                                                             t_TAIL_04,
                                                             t_TAIL_05,
                                                             t_TAIL_06,
                                                             t_TAIL_07> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&, bsl::variant<t_HEAD, t_TAIL_01,
                                                              t_TAIL_02,
                                                              t_TAIL_03,
                                                              t_TAIL_04,
                                                              t_TAIL_05,
                                                              t_TAIL_06,
                                                              t_TAIL_07>&);
 
    typedef bsl::variant<t_HEAD, t_TAIL_01,
                                 t_TAIL_02,
                                 t_TAIL_03,
                                 t_TAIL_04,
                                 t_TAIL_05,
                                 t_TAIL_06,
                                 t_TAIL_07> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *moveMap()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl)};
        return s_mapArray;
    }
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 8
template <class t_RET, class t_VISITOR, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08>
struct Variant_VTable<t_RET, t_VISITOR, bsl::variant<t_HEAD, t_TAIL_01,
                                                             t_TAIL_02,
                                                             t_TAIL_03,
                                                             t_TAIL_04,
                                                             t_TAIL_05,
                                                             t_TAIL_06,
                                                             t_TAIL_07,
                                                             t_TAIL_08> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&, bsl::variant<t_HEAD, t_TAIL_01,
                                                              t_TAIL_02,
                                                              t_TAIL_03,
                                                              t_TAIL_04,
                                                              t_TAIL_05,
                                                              t_TAIL_06,
                                                              t_TAIL_07,
                                                              t_TAIL_08>&);
 
    typedef bsl::variant<t_HEAD, t_TAIL_01,
                                 t_TAIL_02,
                                 t_TAIL_03,
                                 t_TAIL_04,
                                 t_TAIL_05,
                                 t_TAIL_06,
                                 t_TAIL_07,
                                 t_TAIL_08> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *moveMap()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl)};
        return s_mapArray;
    }
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 9
template <class t_RET, class t_VISITOR, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09>
struct Variant_VTable<t_RET, t_VISITOR, bsl::variant<t_HEAD, t_TAIL_01,
                                                             t_TAIL_02,
                                                             t_TAIL_03,
                                                             t_TAIL_04,
                                                             t_TAIL_05,
                                                             t_TAIL_06,
                                                             t_TAIL_07,
                                                             t_TAIL_08,
                                                             t_TAIL_09> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&, bsl::variant<t_HEAD, t_TAIL_01,
                                                              t_TAIL_02,
                                                              t_TAIL_03,
                                                              t_TAIL_04,
                                                              t_TAIL_05,
                                                              t_TAIL_06,
                                                              t_TAIL_07,
                                                              t_TAIL_08,
                                                              t_TAIL_09>&);
 
    typedef bsl::variant<t_HEAD, t_TAIL_01,
                                 t_TAIL_02,
                                 t_TAIL_03,
                                 t_TAIL_04,
                                 t_TAIL_05,
                                 t_TAIL_06,
                                 t_TAIL_07,
                                 t_TAIL_08,
                                 t_TAIL_09> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *moveMap()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl)};
        return s_mapArray;
    }
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 10
template <class t_RET, class t_VISITOR, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09,
                                                      class t_TAIL_10>
struct Variant_VTable<t_RET, t_VISITOR, bsl::variant<t_HEAD, t_TAIL_01,
                                                             t_TAIL_02,
                                                             t_TAIL_03,
                                                             t_TAIL_04,
                                                             t_TAIL_05,
                                                             t_TAIL_06,
                                                             t_TAIL_07,
                                                             t_TAIL_08,
                                                             t_TAIL_09,
                                                             t_TAIL_10> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&, bsl::variant<t_HEAD, t_TAIL_01,
                                                              t_TAIL_02,
                                                              t_TAIL_03,
                                                              t_TAIL_04,
                                                              t_TAIL_05,
                                                              t_TAIL_06,
                                                              t_TAIL_07,
                                                              t_TAIL_08,
                                                              t_TAIL_09,
                                                              t_TAIL_10>&);
 
    typedef bsl::variant<t_HEAD, t_TAIL_01,
                                 t_TAIL_02,
                                 t_TAIL_03,
                                 t_TAIL_04,
                                 t_TAIL_05,
                                 t_TAIL_06,
                                 t_TAIL_07,
                                 t_TAIL_08,
                                 t_TAIL_09,
                                 t_TAIL_10> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *moveMap()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl)};
        return s_mapArray;
    }
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 11
template <class t_RET, class t_VISITOR, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09,
                                                      class t_TAIL_10,
                                                      class t_TAIL_11>
struct Variant_VTable<t_RET, t_VISITOR, bsl::variant<t_HEAD, t_TAIL_01,
                                                             t_TAIL_02,
                                                             t_TAIL_03,
                                                             t_TAIL_04,
                                                             t_TAIL_05,
                                                             t_TAIL_06,
                                                             t_TAIL_07,
                                                             t_TAIL_08,
                                                             t_TAIL_09,
                                                             t_TAIL_10,
                                                             t_TAIL_11> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&, bsl::variant<t_HEAD, t_TAIL_01,
                                                              t_TAIL_02,
                                                              t_TAIL_03,
                                                              t_TAIL_04,
                                                              t_TAIL_05,
                                                              t_TAIL_06,
                                                              t_TAIL_07,
                                                              t_TAIL_08,
                                                              t_TAIL_09,
                                                              t_TAIL_10,
                                                              t_TAIL_11>&);
 
    typedef bsl::variant<t_HEAD, t_TAIL_01,
                                 t_TAIL_02,
                                 t_TAIL_03,
                                 t_TAIL_04,
                                 t_TAIL_05,
                                 t_TAIL_06,
                                 t_TAIL_07,
                                 t_TAIL_08,
                                 t_TAIL_09,
                                 t_TAIL_10,
                                 t_TAIL_11> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *moveMap()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl)};
        return s_mapArray;
    }
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 12
template <class t_RET, class t_VISITOR, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09,
                                                      class t_TAIL_10,
                                                      class t_TAIL_11,
                                                      class t_TAIL_12>
struct Variant_VTable<t_RET, t_VISITOR, bsl::variant<t_HEAD, t_TAIL_01,
                                                             t_TAIL_02,
                                                             t_TAIL_03,
                                                             t_TAIL_04,
                                                             t_TAIL_05,
                                                             t_TAIL_06,
                                                             t_TAIL_07,
                                                             t_TAIL_08,
                                                             t_TAIL_09,
                                                             t_TAIL_10,
                                                             t_TAIL_11,
                                                             t_TAIL_12> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&, bsl::variant<t_HEAD, t_TAIL_01,
                                                              t_TAIL_02,
                                                              t_TAIL_03,
                                                              t_TAIL_04,
                                                              t_TAIL_05,
                                                              t_TAIL_06,
                                                              t_TAIL_07,
                                                              t_TAIL_08,
                                                              t_TAIL_09,
                                                              t_TAIL_10,
                                                              t_TAIL_11,
                                                              t_TAIL_12>&);
 
    typedef bsl::variant<t_HEAD, t_TAIL_01,
                                 t_TAIL_02,
                                 t_TAIL_03,
                                 t_TAIL_04,
                                 t_TAIL_05,
                                 t_TAIL_06,
                                 t_TAIL_07,
                                 t_TAIL_08,
                                 t_TAIL_09,
                                 t_TAIL_10,
                                 t_TAIL_11,
                                 t_TAIL_12> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_12>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *moveMap()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_12>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_12>::
            functionImpl)};
        return s_mapArray;
    }
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 13
template <class t_RET, class t_VISITOR, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09,
                                                      class t_TAIL_10,
                                                      class t_TAIL_11,
                                                      class t_TAIL_12,
                                                      class t_TAIL_13>
struct Variant_VTable<t_RET, t_VISITOR, bsl::variant<t_HEAD, t_TAIL_01,
                                                             t_TAIL_02,
                                                             t_TAIL_03,
                                                             t_TAIL_04,
                                                             t_TAIL_05,
                                                             t_TAIL_06,
                                                             t_TAIL_07,
                                                             t_TAIL_08,
                                                             t_TAIL_09,
                                                             t_TAIL_10,
                                                             t_TAIL_11,
                                                             t_TAIL_12,
                                                             t_TAIL_13> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&, bsl::variant<t_HEAD, t_TAIL_01,
                                                              t_TAIL_02,
                                                              t_TAIL_03,
                                                              t_TAIL_04,
                                                              t_TAIL_05,
                                                              t_TAIL_06,
                                                              t_TAIL_07,
                                                              t_TAIL_08,
                                                              t_TAIL_09,
                                                              t_TAIL_10,
                                                              t_TAIL_11,
                                                              t_TAIL_12,
                                                              t_TAIL_13>&);
 
    typedef bsl::variant<t_HEAD, t_TAIL_01,
                                 t_TAIL_02,
                                 t_TAIL_03,
                                 t_TAIL_04,
                                 t_TAIL_05,
                                 t_TAIL_06,
                                 t_TAIL_07,
                                 t_TAIL_08,
                                 t_TAIL_09,
                                 t_TAIL_10,
                                 t_TAIL_11,
                                 t_TAIL_12,
                                 t_TAIL_13> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_12>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_13>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *moveMap()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_12>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_13>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_12>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_13>::
            functionImpl)};
        return s_mapArray;
    }
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 14
template <class t_RET, class t_VISITOR, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09,
                                                      class t_TAIL_10,
                                                      class t_TAIL_11,
                                                      class t_TAIL_12,
                                                      class t_TAIL_13,
                                                      class t_TAIL_14>
struct Variant_VTable<t_RET, t_VISITOR, bsl::variant<t_HEAD, t_TAIL_01,
                                                             t_TAIL_02,
                                                             t_TAIL_03,
                                                             t_TAIL_04,
                                                             t_TAIL_05,
                                                             t_TAIL_06,
                                                             t_TAIL_07,
                                                             t_TAIL_08,
                                                             t_TAIL_09,
                                                             t_TAIL_10,
                                                             t_TAIL_11,
                                                             t_TAIL_12,
                                                             t_TAIL_13,
                                                             t_TAIL_14> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&, bsl::variant<t_HEAD, t_TAIL_01,
                                                              t_TAIL_02,
                                                              t_TAIL_03,
                                                              t_TAIL_04,
                                                              t_TAIL_05,
                                                              t_TAIL_06,
                                                              t_TAIL_07,
                                                              t_TAIL_08,
                                                              t_TAIL_09,
                                                              t_TAIL_10,
                                                              t_TAIL_11,
                                                              t_TAIL_12,
                                                              t_TAIL_13,
                                                              t_TAIL_14>&);
 
    typedef bsl::variant<t_HEAD, t_TAIL_01,
                                 t_TAIL_02,
                                 t_TAIL_03,
                                 t_TAIL_04,
                                 t_TAIL_05,
                                 t_TAIL_06,
                                 t_TAIL_07,
                                 t_TAIL_08,
                                 t_TAIL_09,
                                 t_TAIL_10,
                                 t_TAIL_11,
                                 t_TAIL_12,
                                 t_TAIL_13,
                                 t_TAIL_14> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_12>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_13>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_14>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *moveMap()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_12>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_13>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_14>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_12>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_13>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_14>::
            functionImpl)};
        return s_mapArray;
    }
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 15
template <class t_RET, class t_VISITOR, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09,
                                                      class t_TAIL_10,
                                                      class t_TAIL_11,
                                                      class t_TAIL_12,
                                                      class t_TAIL_13,
                                                      class t_TAIL_14,
                                                      class t_TAIL_15>
struct Variant_VTable<t_RET, t_VISITOR, bsl::variant<t_HEAD, t_TAIL_01,
                                                             t_TAIL_02,
                                                             t_TAIL_03,
                                                             t_TAIL_04,
                                                             t_TAIL_05,
                                                             t_TAIL_06,
                                                             t_TAIL_07,
                                                             t_TAIL_08,
                                                             t_TAIL_09,
                                                             t_TAIL_10,
                                                             t_TAIL_11,
                                                             t_TAIL_12,
                                                             t_TAIL_13,
                                                             t_TAIL_14,
                                                             t_TAIL_15> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&, bsl::variant<t_HEAD, t_TAIL_01,
                                                              t_TAIL_02,
                                                              t_TAIL_03,
                                                              t_TAIL_04,
                                                              t_TAIL_05,
                                                              t_TAIL_06,
                                                              t_TAIL_07,
                                                              t_TAIL_08,
                                                              t_TAIL_09,
                                                              t_TAIL_10,
                                                              t_TAIL_11,
                                                              t_TAIL_12,
                                                              t_TAIL_13,
                                                              t_TAIL_14,
                                                              t_TAIL_15>&);
 
    typedef bsl::variant<t_HEAD, t_TAIL_01,
                                 t_TAIL_02,
                                 t_TAIL_03,
                                 t_TAIL_04,
                                 t_TAIL_05,
                                 t_TAIL_06,
                                 t_TAIL_07,
                                 t_TAIL_08,
                                 t_TAIL_09,
                                 t_TAIL_10,
                                 t_TAIL_11,
                                 t_TAIL_12,
                                 t_TAIL_13,
                                 t_TAIL_14,
                                 t_TAIL_15> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_12>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_13>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_14>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_15>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *moveMap()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_12>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_13>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_14>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_15>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_12>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_13>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_14>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_15>::
            functionImpl)};
        return s_mapArray;
    }
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 16
template <class t_RET, class t_VISITOR, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09,
                                                      class t_TAIL_10,
                                                      class t_TAIL_11,
                                                      class t_TAIL_12,
                                                      class t_TAIL_13,
                                                      class t_TAIL_14,
                                                      class t_TAIL_15,
                                                      class t_TAIL_16>
struct Variant_VTable<t_RET, t_VISITOR, bsl::variant<t_HEAD, t_TAIL_01,
                                                             t_TAIL_02,
                                                             t_TAIL_03,
                                                             t_TAIL_04,
                                                             t_TAIL_05,
                                                             t_TAIL_06,
                                                             t_TAIL_07,
                                                             t_TAIL_08,
                                                             t_TAIL_09,
                                                             t_TAIL_10,
                                                             t_TAIL_11,
                                                             t_TAIL_12,
                                                             t_TAIL_13,
                                                             t_TAIL_14,
                                                             t_TAIL_15,
                                                             t_TAIL_16> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&, bsl::variant<t_HEAD, t_TAIL_01,
                                                              t_TAIL_02,
                                                              t_TAIL_03,
                                                              t_TAIL_04,
                                                              t_TAIL_05,
                                                              t_TAIL_06,
                                                              t_TAIL_07,
                                                              t_TAIL_08,
                                                              t_TAIL_09,
                                                              t_TAIL_10,
                                                              t_TAIL_11,
                                                              t_TAIL_12,
                                                              t_TAIL_13,
                                                              t_TAIL_14,
                                                              t_TAIL_15,
                                                              t_TAIL_16>&);
 
    typedef bsl::variant<t_HEAD, t_TAIL_01,
                                 t_TAIL_02,
                                 t_TAIL_03,
                                 t_TAIL_04,
                                 t_TAIL_05,
                                 t_TAIL_06,
                                 t_TAIL_07,
                                 t_TAIL_08,
                                 t_TAIL_09,
                                 t_TAIL_10,
                                 t_TAIL_11,
                                 t_TAIL_12,
                                 t_TAIL_13,
                                 t_TAIL_14,
                                 t_TAIL_15,
                                 t_TAIL_16> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_12>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_13>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_14>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_15>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_16>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *moveMap()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_12>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_13>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_14>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_15>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_16>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_12>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_13>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_14>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_15>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_16>::
            functionImpl)};
        return s_mapArray;
    }
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 17
template <class t_RET, class t_VISITOR, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09,
                                                      class t_TAIL_10,
                                                      class t_TAIL_11,
                                                      class t_TAIL_12,
                                                      class t_TAIL_13,
                                                      class t_TAIL_14,
                                                      class t_TAIL_15,
                                                      class t_TAIL_16,
                                                      class t_TAIL_17>
struct Variant_VTable<t_RET, t_VISITOR, bsl::variant<t_HEAD, t_TAIL_01,
                                                             t_TAIL_02,
                                                             t_TAIL_03,
                                                             t_TAIL_04,
                                                             t_TAIL_05,
                                                             t_TAIL_06,
                                                             t_TAIL_07,
                                                             t_TAIL_08,
                                                             t_TAIL_09,
                                                             t_TAIL_10,
                                                             t_TAIL_11,
                                                             t_TAIL_12,
                                                             t_TAIL_13,
                                                             t_TAIL_14,
                                                             t_TAIL_15,
                                                             t_TAIL_16,
                                                             t_TAIL_17> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&, bsl::variant<t_HEAD, t_TAIL_01,
                                                              t_TAIL_02,
                                                              t_TAIL_03,
                                                              t_TAIL_04,
                                                              t_TAIL_05,
                                                              t_TAIL_06,
                                                              t_TAIL_07,
                                                              t_TAIL_08,
                                                              t_TAIL_09,
                                                              t_TAIL_10,
                                                              t_TAIL_11,
                                                              t_TAIL_12,
                                                              t_TAIL_13,
                                                              t_TAIL_14,
                                                              t_TAIL_15,
                                                              t_TAIL_16,
                                                              t_TAIL_17>&);
 
    typedef bsl::variant<t_HEAD, t_TAIL_01,
                                 t_TAIL_02,
                                 t_TAIL_03,
                                 t_TAIL_04,
                                 t_TAIL_05,
                                 t_TAIL_06,
                                 t_TAIL_07,
                                 t_TAIL_08,
                                 t_TAIL_09,
                                 t_TAIL_10,
                                 t_TAIL_11,
                                 t_TAIL_12,
                                 t_TAIL_13,
                                 t_TAIL_14,
                                 t_TAIL_15,
                                 t_TAIL_16,
                                 t_TAIL_17> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_12>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_13>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_14>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_15>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_16>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_17>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *moveMap()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_12>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_13>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_14>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_15>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_16>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_17>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_12>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_13>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_14>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_15>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_16>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_17>::
            functionImpl)};
        return s_mapArray;
    }
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 18
template <class t_RET, class t_VISITOR, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09,
                                                      class t_TAIL_10,
                                                      class t_TAIL_11,
                                                      class t_TAIL_12,
                                                      class t_TAIL_13,
                                                      class t_TAIL_14,
                                                      class t_TAIL_15,
                                                      class t_TAIL_16,
                                                      class t_TAIL_17,
                                                      class t_TAIL_18>
struct Variant_VTable<t_RET, t_VISITOR, bsl::variant<t_HEAD, t_TAIL_01,
                                                             t_TAIL_02,
                                                             t_TAIL_03,
                                                             t_TAIL_04,
                                                             t_TAIL_05,
                                                             t_TAIL_06,
                                                             t_TAIL_07,
                                                             t_TAIL_08,
                                                             t_TAIL_09,
                                                             t_TAIL_10,
                                                             t_TAIL_11,
                                                             t_TAIL_12,
                                                             t_TAIL_13,
                                                             t_TAIL_14,
                                                             t_TAIL_15,
                                                             t_TAIL_16,
                                                             t_TAIL_17,
                                                             t_TAIL_18> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&, bsl::variant<t_HEAD, t_TAIL_01,
                                                              t_TAIL_02,
                                                              t_TAIL_03,
                                                              t_TAIL_04,
                                                              t_TAIL_05,
                                                              t_TAIL_06,
                                                              t_TAIL_07,
                                                              t_TAIL_08,
                                                              t_TAIL_09,
                                                              t_TAIL_10,
                                                              t_TAIL_11,
                                                              t_TAIL_12,
                                                              t_TAIL_13,
                                                              t_TAIL_14,
                                                              t_TAIL_15,
                                                              t_TAIL_16,
                                                              t_TAIL_17,
                                                              t_TAIL_18>&);
 
    typedef bsl::variant<t_HEAD, t_TAIL_01,
                                 t_TAIL_02,
                                 t_TAIL_03,
                                 t_TAIL_04,
                                 t_TAIL_05,
                                 t_TAIL_06,
                                 t_TAIL_07,
                                 t_TAIL_08,
                                 t_TAIL_09,
                                 t_TAIL_10,
                                 t_TAIL_11,
                                 t_TAIL_12,
                                 t_TAIL_13,
                                 t_TAIL_14,
                                 t_TAIL_15,
                                 t_TAIL_16,
                                 t_TAIL_17,
                                 t_TAIL_18> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_12>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_13>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_14>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_15>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_16>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_17>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_18>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *moveMap()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_12>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_13>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_14>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_15>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_16>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_17>::
            functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL_18>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_12>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_13>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_14>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_15>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_16>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_17>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_18>::
            functionImpl)};
        return s_mapArray;
    }
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 0
template <class t_RET, class t_VISITOR, class t_HEAD>
struct Variant_VTable<t_RET,
                      t_VISITOR,
                      const bsl::variant<t_HEAD> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&,
                             const bsl::variant<t_HEAD>&);
 
    typedef const bsl::variant<t_HEAD> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl)};
        return s_mapArray;
    }
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 1
template <class t_RET, class t_VISITOR, class t_HEAD, class t_TAIL_01>
struct Variant_VTable<t_RET,
                      t_VISITOR,
                      const bsl::variant<t_HEAD, t_TAIL_01> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&,
                             const bsl::variant<t_HEAD, t_TAIL_01>&);
 
    typedef const bsl::variant<t_HEAD, t_TAIL_01> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl)};
        return s_mapArray;
    }
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 2
template <class t_RET, class t_VISITOR, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02>
struct Variant_VTable<t_RET,
                      t_VISITOR,
                      const bsl::variant<t_HEAD, t_TAIL_01,
                                                 t_TAIL_02> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&,
                             const bsl::variant<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02>&);
 
    typedef const bsl::variant<t_HEAD, t_TAIL_01,
                                       t_TAIL_02> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl)};
        return s_mapArray;
    }
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 3
template <class t_RET, class t_VISITOR, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03>
struct Variant_VTable<t_RET,
                      t_VISITOR,
                      const bsl::variant<t_HEAD, t_TAIL_01,
                                                 t_TAIL_02,
                                                 t_TAIL_03> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&,
                             const bsl::variant<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03>&);
 
    typedef const bsl::variant<t_HEAD, t_TAIL_01,
                                       t_TAIL_02,
                                       t_TAIL_03> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl)};
        return s_mapArray;
    }
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 4
template <class t_RET, class t_VISITOR, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04>
struct Variant_VTable<t_RET,
                      t_VISITOR,
                      const bsl::variant<t_HEAD, t_TAIL_01,
                                                 t_TAIL_02,
                                                 t_TAIL_03,
                                                 t_TAIL_04> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&,
                             const bsl::variant<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04>&);
 
    typedef const bsl::variant<t_HEAD, t_TAIL_01,
                                       t_TAIL_02,
                                       t_TAIL_03,
                                       t_TAIL_04> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl)};
        return s_mapArray;
    }
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 5
template <class t_RET, class t_VISITOR, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05>
struct Variant_VTable<t_RET,
                      t_VISITOR,
                      const bsl::variant<t_HEAD, t_TAIL_01,
                                                 t_TAIL_02,
                                                 t_TAIL_03,
                                                 t_TAIL_04,
                                                 t_TAIL_05> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&,
                             const bsl::variant<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05>&);
 
    typedef const bsl::variant<t_HEAD, t_TAIL_01,
                                       t_TAIL_02,
                                       t_TAIL_03,
                                       t_TAIL_04,
                                       t_TAIL_05> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl)};
        return s_mapArray;
    }
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 6
template <class t_RET, class t_VISITOR, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06>
struct Variant_VTable<t_RET,
                      t_VISITOR,
                      const bsl::variant<t_HEAD, t_TAIL_01,
                                                 t_TAIL_02,
                                                 t_TAIL_03,
                                                 t_TAIL_04,
                                                 t_TAIL_05,
                                                 t_TAIL_06> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&,
                             const bsl::variant<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06>&);
 
    typedef const bsl::variant<t_HEAD, t_TAIL_01,
                                       t_TAIL_02,
                                       t_TAIL_03,
                                       t_TAIL_04,
                                       t_TAIL_05,
                                       t_TAIL_06> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl)};
        return s_mapArray;
    }
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 7
template <class t_RET, class t_VISITOR, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07>
struct Variant_VTable<t_RET,
                      t_VISITOR,
                      const bsl::variant<t_HEAD, t_TAIL_01,
                                                 t_TAIL_02,
                                                 t_TAIL_03,
                                                 t_TAIL_04,
                                                 t_TAIL_05,
                                                 t_TAIL_06,
                                                 t_TAIL_07> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&,
                             const bsl::variant<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07>&);
 
    typedef const bsl::variant<t_HEAD, t_TAIL_01,
                                       t_TAIL_02,
                                       t_TAIL_03,
                                       t_TAIL_04,
                                       t_TAIL_05,
                                       t_TAIL_06,
                                       t_TAIL_07> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl)};
        return s_mapArray;
    }
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 8
template <class t_RET, class t_VISITOR, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08>
struct Variant_VTable<t_RET,
                      t_VISITOR,
                      const bsl::variant<t_HEAD, t_TAIL_01,
                                                 t_TAIL_02,
                                                 t_TAIL_03,
                                                 t_TAIL_04,
                                                 t_TAIL_05,
                                                 t_TAIL_06,
                                                 t_TAIL_07,
                                                 t_TAIL_08> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&,
                             const bsl::variant<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08>&);
 
    typedef const bsl::variant<t_HEAD, t_TAIL_01,
                                       t_TAIL_02,
                                       t_TAIL_03,
                                       t_TAIL_04,
                                       t_TAIL_05,
                                       t_TAIL_06,
                                       t_TAIL_07,
                                       t_TAIL_08> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl)};
        return s_mapArray;
    }
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 9
template <class t_RET, class t_VISITOR, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09>
struct Variant_VTable<t_RET,
                      t_VISITOR,
                      const bsl::variant<t_HEAD, t_TAIL_01,
                                                 t_TAIL_02,
                                                 t_TAIL_03,
                                                 t_TAIL_04,
                                                 t_TAIL_05,
                                                 t_TAIL_06,
                                                 t_TAIL_07,
                                                 t_TAIL_08,
                                                 t_TAIL_09> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&,
                             const bsl::variant<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09>&);
 
    typedef const bsl::variant<t_HEAD, t_TAIL_01,
                                       t_TAIL_02,
                                       t_TAIL_03,
                                       t_TAIL_04,
                                       t_TAIL_05,
                                       t_TAIL_06,
                                       t_TAIL_07,
                                       t_TAIL_08,
                                       t_TAIL_09> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl)};
        return s_mapArray;
    }
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 10
template <class t_RET, class t_VISITOR, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09,
                                                      class t_TAIL_10>
struct Variant_VTable<t_RET,
                      t_VISITOR,
                      const bsl::variant<t_HEAD, t_TAIL_01,
                                                 t_TAIL_02,
                                                 t_TAIL_03,
                                                 t_TAIL_04,
                                                 t_TAIL_05,
                                                 t_TAIL_06,
                                                 t_TAIL_07,
                                                 t_TAIL_08,
                                                 t_TAIL_09,
                                                 t_TAIL_10> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&,
                             const bsl::variant<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09,
                                                        t_TAIL_10>&);
 
    typedef const bsl::variant<t_HEAD, t_TAIL_01,
                                       t_TAIL_02,
                                       t_TAIL_03,
                                       t_TAIL_04,
                                       t_TAIL_05,
                                       t_TAIL_06,
                                       t_TAIL_07,
                                       t_TAIL_08,
                                       t_TAIL_09,
                                       t_TAIL_10> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl)};
        return s_mapArray;
    }
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 11
template <class t_RET, class t_VISITOR, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09,
                                                      class t_TAIL_10,
                                                      class t_TAIL_11>
struct Variant_VTable<t_RET,
                      t_VISITOR,
                      const bsl::variant<t_HEAD, t_TAIL_01,
                                                 t_TAIL_02,
                                                 t_TAIL_03,
                                                 t_TAIL_04,
                                                 t_TAIL_05,
                                                 t_TAIL_06,
                                                 t_TAIL_07,
                                                 t_TAIL_08,
                                                 t_TAIL_09,
                                                 t_TAIL_10,
                                                 t_TAIL_11> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&,
                             const bsl::variant<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09,
                                                        t_TAIL_10,
                                                        t_TAIL_11>&);
 
    typedef const bsl::variant<t_HEAD, t_TAIL_01,
                                       t_TAIL_02,
                                       t_TAIL_03,
                                       t_TAIL_04,
                                       t_TAIL_05,
                                       t_TAIL_06,
                                       t_TAIL_07,
                                       t_TAIL_08,
                                       t_TAIL_09,
                                       t_TAIL_10,
                                       t_TAIL_11> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl)};
        return s_mapArray;
    }
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 12
template <class t_RET, class t_VISITOR, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09,
                                                      class t_TAIL_10,
                                                      class t_TAIL_11,
                                                      class t_TAIL_12>
struct Variant_VTable<t_RET,
                      t_VISITOR,
                      const bsl::variant<t_HEAD, t_TAIL_01,
                                                 t_TAIL_02,
                                                 t_TAIL_03,
                                                 t_TAIL_04,
                                                 t_TAIL_05,
                                                 t_TAIL_06,
                                                 t_TAIL_07,
                                                 t_TAIL_08,
                                                 t_TAIL_09,
                                                 t_TAIL_10,
                                                 t_TAIL_11,
                                                 t_TAIL_12> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&,
                             const bsl::variant<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09,
                                                        t_TAIL_10,
                                                        t_TAIL_11,
                                                        t_TAIL_12>&);
 
    typedef const bsl::variant<t_HEAD, t_TAIL_01,
                                       t_TAIL_02,
                                       t_TAIL_03,
                                       t_TAIL_04,
                                       t_TAIL_05,
                                       t_TAIL_06,
                                       t_TAIL_07,
                                       t_TAIL_08,
                                       t_TAIL_09,
                                       t_TAIL_10,
                                       t_TAIL_11,
                                       t_TAIL_12> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_12>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_12>::
            functionImpl)};
        return s_mapArray;
    }
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 13
template <class t_RET, class t_VISITOR, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09,
                                                      class t_TAIL_10,
                                                      class t_TAIL_11,
                                                      class t_TAIL_12,
                                                      class t_TAIL_13>
struct Variant_VTable<t_RET,
                      t_VISITOR,
                      const bsl::variant<t_HEAD, t_TAIL_01,
                                                 t_TAIL_02,
                                                 t_TAIL_03,
                                                 t_TAIL_04,
                                                 t_TAIL_05,
                                                 t_TAIL_06,
                                                 t_TAIL_07,
                                                 t_TAIL_08,
                                                 t_TAIL_09,
                                                 t_TAIL_10,
                                                 t_TAIL_11,
                                                 t_TAIL_12,
                                                 t_TAIL_13> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&,
                             const bsl::variant<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09,
                                                        t_TAIL_10,
                                                        t_TAIL_11,
                                                        t_TAIL_12,
                                                        t_TAIL_13>&);
 
    typedef const bsl::variant<t_HEAD, t_TAIL_01,
                                       t_TAIL_02,
                                       t_TAIL_03,
                                       t_TAIL_04,
                                       t_TAIL_05,
                                       t_TAIL_06,
                                       t_TAIL_07,
                                       t_TAIL_08,
                                       t_TAIL_09,
                                       t_TAIL_10,
                                       t_TAIL_11,
                                       t_TAIL_12,
                                       t_TAIL_13> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_12>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_13>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_12>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_13>::
            functionImpl)};
        return s_mapArray;
    }
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 14
template <class t_RET, class t_VISITOR, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09,
                                                      class t_TAIL_10,
                                                      class t_TAIL_11,
                                                      class t_TAIL_12,
                                                      class t_TAIL_13,
                                                      class t_TAIL_14>
struct Variant_VTable<t_RET,
                      t_VISITOR,
                      const bsl::variant<t_HEAD, t_TAIL_01,
                                                 t_TAIL_02,
                                                 t_TAIL_03,
                                                 t_TAIL_04,
                                                 t_TAIL_05,
                                                 t_TAIL_06,
                                                 t_TAIL_07,
                                                 t_TAIL_08,
                                                 t_TAIL_09,
                                                 t_TAIL_10,
                                                 t_TAIL_11,
                                                 t_TAIL_12,
                                                 t_TAIL_13,
                                                 t_TAIL_14> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&,
                             const bsl::variant<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09,
                                                        t_TAIL_10,
                                                        t_TAIL_11,
                                                        t_TAIL_12,
                                                        t_TAIL_13,
                                                        t_TAIL_14>&);
 
    typedef const bsl::variant<t_HEAD, t_TAIL_01,
                                       t_TAIL_02,
                                       t_TAIL_03,
                                       t_TAIL_04,
                                       t_TAIL_05,
                                       t_TAIL_06,
                                       t_TAIL_07,
                                       t_TAIL_08,
                                       t_TAIL_09,
                                       t_TAIL_10,
                                       t_TAIL_11,
                                       t_TAIL_12,
                                       t_TAIL_13,
                                       t_TAIL_14> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_12>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_13>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_14>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_12>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_13>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_14>::
            functionImpl)};
        return s_mapArray;
    }
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 15
template <class t_RET, class t_VISITOR, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09,
                                                      class t_TAIL_10,
                                                      class t_TAIL_11,
                                                      class t_TAIL_12,
                                                      class t_TAIL_13,
                                                      class t_TAIL_14,
                                                      class t_TAIL_15>
struct Variant_VTable<t_RET,
                      t_VISITOR,
                      const bsl::variant<t_HEAD, t_TAIL_01,
                                                 t_TAIL_02,
                                                 t_TAIL_03,
                                                 t_TAIL_04,
                                                 t_TAIL_05,
                                                 t_TAIL_06,
                                                 t_TAIL_07,
                                                 t_TAIL_08,
                                                 t_TAIL_09,
                                                 t_TAIL_10,
                                                 t_TAIL_11,
                                                 t_TAIL_12,
                                                 t_TAIL_13,
                                                 t_TAIL_14,
                                                 t_TAIL_15> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&,
                             const bsl::variant<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09,
                                                        t_TAIL_10,
                                                        t_TAIL_11,
                                                        t_TAIL_12,
                                                        t_TAIL_13,
                                                        t_TAIL_14,
                                                        t_TAIL_15>&);
 
    typedef const bsl::variant<t_HEAD, t_TAIL_01,
                                       t_TAIL_02,
                                       t_TAIL_03,
                                       t_TAIL_04,
                                       t_TAIL_05,
                                       t_TAIL_06,
                                       t_TAIL_07,
                                       t_TAIL_08,
                                       t_TAIL_09,
                                       t_TAIL_10,
                                       t_TAIL_11,
                                       t_TAIL_12,
                                       t_TAIL_13,
                                       t_TAIL_14,
                                       t_TAIL_15> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_12>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_13>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_14>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_15>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_12>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_13>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_14>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_15>::
            functionImpl)};
        return s_mapArray;
    }
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 16
template <class t_RET, class t_VISITOR, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09,
                                                      class t_TAIL_10,
                                                      class t_TAIL_11,
                                                      class t_TAIL_12,
                                                      class t_TAIL_13,
                                                      class t_TAIL_14,
                                                      class t_TAIL_15,
                                                      class t_TAIL_16>
struct Variant_VTable<t_RET,
                      t_VISITOR,
                      const bsl::variant<t_HEAD, t_TAIL_01,
                                                 t_TAIL_02,
                                                 t_TAIL_03,
                                                 t_TAIL_04,
                                                 t_TAIL_05,
                                                 t_TAIL_06,
                                                 t_TAIL_07,
                                                 t_TAIL_08,
                                                 t_TAIL_09,
                                                 t_TAIL_10,
                                                 t_TAIL_11,
                                                 t_TAIL_12,
                                                 t_TAIL_13,
                                                 t_TAIL_14,
                                                 t_TAIL_15,
                                                 t_TAIL_16> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&,
                             const bsl::variant<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09,
                                                        t_TAIL_10,
                                                        t_TAIL_11,
                                                        t_TAIL_12,
                                                        t_TAIL_13,
                                                        t_TAIL_14,
                                                        t_TAIL_15,
                                                        t_TAIL_16>&);
 
    typedef const bsl::variant<t_HEAD, t_TAIL_01,
                                       t_TAIL_02,
                                       t_TAIL_03,
                                       t_TAIL_04,
                                       t_TAIL_05,
                                       t_TAIL_06,
                                       t_TAIL_07,
                                       t_TAIL_08,
                                       t_TAIL_09,
                                       t_TAIL_10,
                                       t_TAIL_11,
                                       t_TAIL_12,
                                       t_TAIL_13,
                                       t_TAIL_14,
                                       t_TAIL_15,
                                       t_TAIL_16> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_12>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_13>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_14>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_15>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_16>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_12>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_13>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_14>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_15>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_16>::
            functionImpl)};
        return s_mapArray;
    }
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 17
template <class t_RET, class t_VISITOR, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09,
                                                      class t_TAIL_10,
                                                      class t_TAIL_11,
                                                      class t_TAIL_12,
                                                      class t_TAIL_13,
                                                      class t_TAIL_14,
                                                      class t_TAIL_15,
                                                      class t_TAIL_16,
                                                      class t_TAIL_17>
struct Variant_VTable<t_RET,
                      t_VISITOR,
                      const bsl::variant<t_HEAD, t_TAIL_01,
                                                 t_TAIL_02,
                                                 t_TAIL_03,
                                                 t_TAIL_04,
                                                 t_TAIL_05,
                                                 t_TAIL_06,
                                                 t_TAIL_07,
                                                 t_TAIL_08,
                                                 t_TAIL_09,
                                                 t_TAIL_10,
                                                 t_TAIL_11,
                                                 t_TAIL_12,
                                                 t_TAIL_13,
                                                 t_TAIL_14,
                                                 t_TAIL_15,
                                                 t_TAIL_16,
                                                 t_TAIL_17> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&,
                             const bsl::variant<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09,
                                                        t_TAIL_10,
                                                        t_TAIL_11,
                                                        t_TAIL_12,
                                                        t_TAIL_13,
                                                        t_TAIL_14,
                                                        t_TAIL_15,
                                                        t_TAIL_16,
                                                        t_TAIL_17>&);
 
    typedef const bsl::variant<t_HEAD, t_TAIL_01,
                                       t_TAIL_02,
                                       t_TAIL_03,
                                       t_TAIL_04,
                                       t_TAIL_05,
                                       t_TAIL_06,
                                       t_TAIL_07,
                                       t_TAIL_08,
                                       t_TAIL_09,
                                       t_TAIL_10,
                                       t_TAIL_11,
                                       t_TAIL_12,
                                       t_TAIL_13,
                                       t_TAIL_14,
                                       t_TAIL_15,
                                       t_TAIL_16,
                                       t_TAIL_17> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_12>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_13>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_14>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_15>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_16>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_17>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_12>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_13>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_14>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_15>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_16>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_17>::
            functionImpl)};
        return s_mapArray;
    }
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 18
template <class t_RET, class t_VISITOR, class t_HEAD, class t_TAIL_01,
                                                      class t_TAIL_02,
                                                      class t_TAIL_03,
                                                      class t_TAIL_04,
                                                      class t_TAIL_05,
                                                      class t_TAIL_06,
                                                      class t_TAIL_07,
                                                      class t_TAIL_08,
                                                      class t_TAIL_09,
                                                      class t_TAIL_10,
                                                      class t_TAIL_11,
                                                      class t_TAIL_12,
                                                      class t_TAIL_13,
                                                      class t_TAIL_14,
                                                      class t_TAIL_15,
                                                      class t_TAIL_16,
                                                      class t_TAIL_17,
                                                      class t_TAIL_18>
struct Variant_VTable<t_RET,
                      t_VISITOR,
                      const bsl::variant<t_HEAD, t_TAIL_01,
                                                 t_TAIL_02,
                                                 t_TAIL_03,
                                                 t_TAIL_04,
                                                 t_TAIL_05,
                                                 t_TAIL_06,
                                                 t_TAIL_07,
                                                 t_TAIL_08,
                                                 t_TAIL_09,
                                                 t_TAIL_10,
                                                 t_TAIL_11,
                                                 t_TAIL_12,
                                                 t_TAIL_13,
                                                 t_TAIL_14,
                                                 t_TAIL_15,
                                                 t_TAIL_16,
                                                 t_TAIL_17,
                                                 t_TAIL_18> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&,
                             const bsl::variant<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09,
                                                        t_TAIL_10,
                                                        t_TAIL_11,
                                                        t_TAIL_12,
                                                        t_TAIL_13,
                                                        t_TAIL_14,
                                                        t_TAIL_15,
                                                        t_TAIL_16,
                                                        t_TAIL_17,
                                                        t_TAIL_18>&);
 
    typedef const bsl::variant<t_HEAD, t_TAIL_01,
                                       t_TAIL_02,
                                       t_TAIL_03,
                                       t_TAIL_04,
                                       t_TAIL_05,
                                       t_TAIL_06,
                                       t_TAIL_07,
                                       t_TAIL_08,
                                       t_TAIL_09,
                                       t_TAIL_10,
                                       t_TAIL_11,
                                       t_TAIL_12,
                                       t_TAIL_13,
                                       t_TAIL_14,
                                       t_TAIL_15,
                                       t_TAIL_16,
                                       t_TAIL_17,
                                       t_TAIL_18> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_12>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_13>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_14>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_15>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_16>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_17>::
            functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL_18>::
            functionImpl)};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_01>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_02>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_03>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_04>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_05>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_06>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_07>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_08>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_09>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_10>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_11>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_12>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_13>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_14>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_15>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_16>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_17>::
            functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL_18>::
            functionImpl)};
        return s_mapArray;
    }
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 18
 
#else
// The generated code below is a workaround for the absence of perfect
// forwarding in some compilers.
 
template <class t_RET, class t_VISITOR, class t_VARIANT, class t_ALT_TYPE>
struct Variant_Function {
    static t_RET functionImpl(t_VISITOR& visitor, t_VARIANT& variant)
    {
        typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
        return visitor(ImpUtil::unsafeGet<t_ALT_TYPE>(variant));
    }
};
 
template <class t_VISITOR, class t_VARIANT, class t_ALT_TYPE>
struct Variant_Function<void, t_VISITOR, t_VARIANT, t_ALT_TYPE> {
 
    static void functionImpl(t_VISITOR& visitor, t_VARIANT& variant)
    {
        typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
        visitor(ImpUtil::unsafeGet<t_ALT_TYPE>(variant));
    }
};
 
template <class t_RET, class t_VISITOR, class t_VARIANT, class t_ALT_TYPE>
struct Variant_MoveFunction {
    static t_RET functionImpl(t_VISITOR& visitor, t_VARIANT& variant)
    {
        typedef BloombergLP::bslmf::MovableRefUtil   MoveUtil;
        typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
        return visitor(
                      MoveUtil::move(ImpUtil::unsafeGet<t_ALT_TYPE>(variant)));
    }
};
 
template <class t_VISITOR, class t_VARIANT, class t_ALT_TYPE>
struct Variant_MoveFunction<void, t_VISITOR, t_VARIANT, t_ALT_TYPE> {
 
    static void functionImpl(t_VISITOR& visitor, t_VARIANT& variant)
    {
        typedef BloombergLP::bslmf::MovableRefUtil   MoveUtil;
        typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
        visitor(MoveUtil::move(ImpUtil::unsafeGet<t_ALT_TYPE>(variant)));
    }
};
 
template <class t_RET, class t_VISITOR, class t_VARIANT, class t_ALT_TYPE>
struct Variant_FunctionId {
    static t_RET functionImpl(t_VISITOR& visitor, t_VARIANT& variant)
    {
        typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
        static const size_t t_INDEX = BSLSTL_VARIANT_INDEX_OF(
            t_ALT_TYPE, typename bsl::remove_cv<t_VARIANT>::type);
 
        return visitor(bsl::in_place_index_t<t_INDEX>(),
                       ImpUtil::unsafeGet<t_ALT_TYPE>(variant));
    }
};
 
template <class t_RET, class t_VISITOR, class t_VARIANT, class... t_UNUSED>
struct Variant_VTable;
 
template <class t_RET, class t_VISITOR, class t_HEAD, class... t_TAIL>
struct Variant_VTable<t_RET, t_VISITOR, bsl::variant<t_HEAD, t_TAIL...> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&, bsl::variant<t_HEAD, t_TAIL...>&);
 
    typedef bsl::variant<t_HEAD, t_TAIL...> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL>::
                  functionImpl)...};
        return s_mapArray;
    }
 
    static const FuncPtr *moveMap()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_MoveFunction<t_RET, t_VISITOR, Variant, t_TAIL>::
                  functionImpl)...};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL>::
                  functionImpl)...};
        return s_mapArray;
    }
};
 
template <class t_RET, class t_VISITOR, class t_HEAD, class... t_TAIL>
struct Variant_VTable<t_RET,
                      t_VISITOR,
                      const bsl::variant<t_HEAD, t_TAIL...> > {
 
    typedef t_RET (*FuncPtr)(t_VISITOR&,
                             const bsl::variant<t_HEAD, t_TAIL...>&);
 
    typedef const bsl::variant<t_HEAD, t_TAIL...> Variant;
 
    static const FuncPtr *map()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_Function<t_RET, t_VISITOR, Variant, t_TAIL>::
                  functionImpl)...};
        return s_mapArray;
    }
 
    static const FuncPtr *mapId()
    {
        static const FuncPtr s_mapArray[] = {
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_HEAD>::
                  functionImpl),
            &(Variant_FunctionId<t_RET, t_VISITOR, Variant, t_TAIL>::
                  functionImpl)...};
        return s_mapArray;
    }
};
 
// }}} END GENERATED CODE
#endif
#endif  // BSL_VARIANT_FULL_IMPLEMENTATION
 
}  // close package namespace
 
 
namespace bsl {
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
/// Return the result of invoking the specified `visitor` with the currently
/// active alternative of the specified `variant`, implicitly converting the
/// result to the explicitly specified (template parameter) `t_RET`.  If
/// `variant` does not hold a value, throw an exception of type
/// `bsl::bad_variant_access`.  Note that unlike the `visit` overload below
/// that deduces its return type, this overload does not require the visitor
/// to yield the exact same type for each alternative, but only requires
/// each such type to be implicitly convertible to `t_RET`.  This function
/// differs from the standard in the following ways:
/// * only one variant is supported
/// * constexpr is not implemented
/// * before C++17, only `t_VISITOR(ALTERNATIVE)` form of visitation is
///   supported; cases where the visitor is a pointer to member are not
///   supported.
template <class t_RET, class t_VISITOR, class t_VARIANT>
t_RET visit(t_VISITOR&& visitor, t_VARIANT&& variant)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (variant.valueless_by_exception()) {
        BSLS_THROW(bsl::bad_variant_access());
    }
    return ImpUtil::visit<t_RET>(std::forward<t_VISITOR>(visitor),
                                 std::forward<t_VARIANT>(variant));
}
 
/// Return the result of invoking the specified `visitor` with the currently
/// active alternative of the specified `variant`.  If `variant` does not
/// hold a value, throw an exception of type `bsl::bad_variant_access`. For
/// each alternative, invocation of the visitor with that alternative shall
/// be of the same type and value category.  This function differs from the
/// standard in the following ways:
/// * only one variant is supported
/// * constexpr is not implemented
/// * before C++17, only `t_VISITOR(ALTERNATIVE)` form of visitation is
///   supported; cases where the visitor is a pointer to member are not
///   supported.
template <class t_VISITOR, class t_VARIANT>
typename bsl::invoke_result<
    t_VISITOR,
    typename BloombergLP::bslstl::Variant_CVQualAlt<t_VARIANT, 0>::type>::type
visit(t_VISITOR&& visitor, t_VARIANT&& variant)
{
    typedef typename bsl::invoke_result<
        t_VISITOR&&,
        typename BloombergLP::bslstl::Variant_CVQualAlt<t_VARIANT&&,
                                                        0>::type>::type RET;
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    static_assert(
        BloombergLP::bslstl::
            Variant_IsSameReturnType<RET, t_VISITOR&&, t_VARIANT&&>::value,
        "The value type and category of invoking the visitor with "
        "every alternative is not the same");
    if (variant.valueless_by_exception()) {
        BSLS_THROW(bsl::bad_variant_access());
    }
    return ImpUtil::visit<RET>(std::forward<t_VISITOR>(visitor),
                               std::forward<t_VARIANT>(variant));
}
 
/// Return the result of invoking the specified `visitor` with the currently
/// active alternative of the specified `variant`, implicitly converting the
/// result to the explicitly specified (template parameter) `t_RET`.  If
/// `variant` does not hold a value, throw an exception of type
/// `bsl::bad_variant_access`.  This function is provided in all language
/// versions for compatibility with the C++03 version (see below), but in
/// new code in C++11 and later, `bsl::visit` should be used instead of this
/// function.
template <class t_RET, class t_VISITOR, class t_VARIANT>
t_RET visitR(t_VISITOR& visitor, t_VARIANT&& variant)
{
    return visit<t_RET>(visitor, std::forward<t_VARIANT>(variant));
}
#else  // BSL_VARIANT_FULL_IMPLEMENTATION
 
template <class t_RET, class t_VISITOR, class t_VARIANT>
t_RET visitR(t_VISITOR& visitor, t_VARIANT& variant)
    // Return the result of invoking the specified 'visitor' with the currently
    // active alternative of the specified 'variant', implicitly converting the
    // result to the explicitly specified (template parameter) 't_RET'.  If
    // 'variant' does not hold a value, throw an exception of type
    // 'bsl::bad_variant_access'.  Unlike 'visit', which deduces its return
    // type, this function does not require the visitor to yield the exact same
    // type for each alternative, but only requires each such type to be
    // implicitly convertible to 't_RET'.  Implementation note: Due to
    // limitations of the type deduction facility in C++03, this function can
    // not share the same name as the deduced type 'visit' because it is not
    // possible to discern between invocation of non deduced return type
    // 'visit' where the return type parameter is explicitly specified and
    // invocation of deduced return type 'visit' where the visitor type
    // parameter is explicitly specified.
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (variant.valueless_by_exception()) {
        BSLS_THROW(bsl::bad_variant_access());
    }
    return ImpUtil::visit<t_RET>(visitor, variant);
}
 
template <class t_RET, class t_VISITOR, class t_VARIANT>
t_RET visitR(t_VISITOR&                                visitor,
             BloombergLP::bslmf::MovableRef<t_VARIANT> variant)
    // Return the result of invoking the specified 'visitor' with a
    // 'bslmf::MovableRef' referring to the currently active alternative of the
    // specified 'variant', implicitly converting the result to the explicitly
    // specified (template parameter) 't_RET'.  If 'variant' does not hold a
    // value, throw an exception of type 'bsl::bad_variant_access'.  Unlike
    // 'visit', which deduces its return type, this function does not require
    // the visitor to yield the exact same type for each alternative, but only
    // requires each such type to be implicitly convertible to 't_RET'.
    // Implementation note: Due to limitations of the type deduction facility
    // in C++03, this function can not share the same name as the deduced type
    // 'visit' because it is not possible to discern between invocation of non
    // deduced return type 'visit' where the return type parameter is
    // explicitly specified and invocation of deduced return type 'visit' where
    // the visitor type parameter is explicitly specified.
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    t_VARIANT& lvalue = variant;
    if (lvalue.valueless_by_exception()) {
        BSLS_THROW(bsl::bad_variant_access());
    }
    return ImpUtil::moveVisit<t_RET>(visitor, lvalue);
}
 
template <class t_VISITOR, class t_VARIANT>
typename bsl::invoke_result<
    t_VISITOR&,
    typename bsl::variant_alternative<0, t_VARIANT>::type&>::type
visit(t_VISITOR& visitor, t_VARIANT& variant)
    // Return the result of invoking the specified 'visitor' with the currently
    // active alternative of the specified 'variant'.  If 'variant' does not
    // hold a value, throw an exception of type 'bsl::bad_variant_access'.  For
    // each alternative, invocation of the visitor with that alternative shall
    // be of the same type and value category.
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (variant.valueless_by_exception()) {
        BSLS_THROW(bsl::bad_variant_access());
    }
    typedef typename bsl::invoke_result<
        t_VISITOR&,
        typename bsl::variant_alternative<0, t_VARIANT>::type&>::type Ret;
 
    BSLMF_ASSERT(
        (BloombergLP::bslstl::
             Variant_IsSameReturnType<Ret, t_VISITOR, t_VARIANT&>::value));
 
    return ImpUtil::visit<Ret>(visitor, variant);
}
 
template <class t_VISITOR, class t_VARIANT>
typename bsl::invoke_result<
    t_VISITOR&,
    BloombergLP::bslmf::MovableRef<
        typename bsl::variant_alternative<0, t_VARIANT>::type> >::type
visit(t_VISITOR& visitor, BloombergLP::bslmf::MovableRef<t_VARIANT> variant)
    // Return the result of invoking the specified 'visitor' with a
    // 'bslmf::MovableRef' referring to the currently active alternative of the
    // specified 'variant'.  If 'variant' does not hold a value, throw an
    // exception of type 'bsl::bad_variant_access'.  For each alternative,
    // invocation of the visitor with that alternative shall be of the same
    // type and value category.
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    t_VARIANT& lvalue = variant;
    if (lvalue.valueless_by_exception()) {
        BSLS_THROW(bsl::bad_variant_access());
    }
    typedef typename bsl::invoke_result<
        t_VISITOR&,
        BloombergLP::bslmf::MovableRef<
            typename bsl::variant_alternative<0, t_VARIANT>::type> >::type Ret;
 
    BSLMF_ASSERT((BloombergLP::bslstl::Variant_IsSameReturnType<
                  Ret,
                  t_VISITOR,
                  BloombergLP::bslmf::MovableRef<t_VARIANT> >::value));
 
    return ImpUtil::moveVisit<Ret>(visitor, lvalue);
}
 
#endif  // BSL_VARIANT_FULL_IMPLEMENTATION
 
}  // close namespace bsl
 
 
namespace bslstl {
 
                          // ========================
                          // class Variant_NoSuchType
                          // ========================
 
/// This component-private trivial tag type is used to distinguish between
/// arguments passed by a user, and an `enable_if` argument.  It is not
/// default constructible so the following construction never invokes a
/// constrained single parameter constructor:
/// @code
///  struct SomeType
///  {
///      SomeType(int, const std::string &s = "default"){}
///  };
///
///  variant<SomeType> o(1, {});
/// @endcode
struct Variant_NoSuchType {
 
    // CREATORS
 
    /// Create a `Variant_NoSuchType` object.
    explicit BSLS_KEYWORD_CONSTEXPR Variant_NoSuchType(
                                                    int) BSLS_KEYWORD_NOEXCEPT;
};
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
/// This component-private class manages an object of type (template
/// parameter) `t_TYPE` that is stored in a `variant` object.  Note that
/// `t_TYPE` may be const-qualified, in which case the internally stored
/// object is not `const`, but the interface of this class prevents
/// modification thereof.
///
/// See @ref bslstl_variant_cpp03 
template <class t_TYPE>
class Variant_DataImp {
 
  private:
    // PRIVATE TYPES
    typedef typename bsl::remove_const<t_TYPE>::type StoredType;
 
    // DATA
    bsls::ObjectBuffer<StoredType> d_buffer;  // in-place 't_TYPE' object
 
  public:
    // CREATORS
    Variant_DataImp() = default;
    // Create a 'Variant_DataImp' object that holds an empty buffer.
 
    // MANIPULATORS
 
    /// Create a `Variant_DataImp` object whose stored `t_TYPE` object is
    /// constructed by forwarding the specified `args` to
    /// `ConstructionUtil::construct` directly.  This means the first
    /// argument in `args` must be a pointer to `bslma::Allocator`, which
    /// will be ignored if `t_TYPE` is not allocator-aware.
    template <class... t_ARGS>
    Variant_DataImp(t_ARGS&&... args);
 
    BSLS_KEYWORD_CONSTEXPR_CPP14 t_TYPE& value() &;
    BSLS_KEYWORD_CONSTEXPR_CPP14 t_TYPE&& value() &&;
    // Return a reference to the stored 't_TYPE' object.  The behavior is
    // undefined unless this object contains a 't_TYPE' object (i.e., this
    // object is currently managing the active alternative of a 'bsl::variant'
    // object).
 
    // ACCESSORS
    BSLS_KEYWORD_CONSTEXPR_CPP14 const t_TYPE& value() const&;
    BSLS_KEYWORD_CONSTEXPR_CPP14 const t_TYPE&& value() const&&;
    // Return a const reference to the stored 't_TYPE' object.  The behavior is
    // undefined unless this object contains a 't_TYPE' object (i.e., this
    // object is currently managing the active alternative of a 'bsl::variant'
    // object).
};
 
/// This component-private union can hold a `Variant_DataImp` object for any
/// alternative in (template parameters) `t_TYPES...`.  The primary template
/// is used when `t_TYPES...` is empty.
template <class... t_TYPES>
union Variant_Union {
};
 
/// This partial specialization uses template recursion because C++ does not
/// support member packs.
template <class t_HEAD, class... t_TAIL>
union Variant_Union<t_HEAD, t_TAIL...> {
 
    // PUBLIC DATA
    Variant_DataImp<t_HEAD>  d_head;
    Variant_Union<t_TAIL...> d_tail;
 
    // CREATORS
    Variant_Union() = default;
    // Create a 'Variant_Union' object having no active alternative.
 
    /// Create a `Variant_Union` object holding an object of type `t_HEAD`
    /// direct-initialized from the specified `args`.
    template <class... t_ARGS>
    Variant_Union(bsl::in_place_index_t<0>, t_ARGS&&... args)
    : d_head(std::forward<t_ARGS>(args)...)
    {
    }
 
    /// Create a `Variant_Union` object holding the alternative at index
    /// (template parameter) `t_INDEX` in (template parameters) 't_HEAD,
    /// t_TAIL...`, direct-initialized from the specified `args'.  Note that
    /// `t_INDEX` is not necessarily the absolute index of the desired
    /// alternative in the `bsl::variant` object.  We use the tag to
    /// "unravel" the union until we get to the desired alternative type.
    ///
    /// See @ref bslstl_variant_cpp03 
    template <size_t t_INDEX, class... t_ARGS>
    Variant_Union(bsl::in_place_index_t<t_INDEX>, t_ARGS&&... args)
    : d_tail(bsl::in_place_index_t<t_INDEX - 1>(),
             std::forward<t_ARGS>(args)...)
    {
    }
};
#else  // BSL_VARIANT_FULL_IMPLEMENTATION
template <class t_TYPE>
class Variant_DataImp {
    // This component-private class manages an object of type (template
    // parameter) 't_TYPE' that is stored in a 'variant' object.  Note that
    // 't_TYPE' may be const-qualified, in which case the internally stored
    // object is not 'const', but the interface of this class prevents
    // modification thereof.
 
  private:
    // PRIVATE TYPES
    typedef typename bsl::remove_const<t_TYPE>::type StoredType;
 
    // DATA
    bsls::ObjectBuffer<StoredType> d_buffer;  // in-place 't_TYPE' object
 
  public:
    // CREATORS
     Variant_DataImp() = default;
        // Create a 'Variant_DataImp' object that holds an empty buffer.
 
    // MANIPULATORS
    t_TYPE& value();
        // Return a reference to the stored 't_TYPE' object.  The behavior is
        // undefined unless the enclosing union contains a 't_TYPE' object
        // (i.e., the enclosing 'bsl::variant' has an active alternative of
        // type 't_TYPE').
 
    // ACCESSORS
    const t_TYPE& value() const;
        // Return a const reference to the stored 't_TYPE' object.  The
        // behavior is undefined unless the enclosing union contains a 't_TYPE'
        // object (i.e., the enclosing 'bsl::variant' has an active alternative
        // of type 't_TYPE').
};
 
#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
// {{{ BEGIN GENERATED CODE
// Command line: sim_cpp11_features.pl bslstl_variant.h
#ifndef BSLSTL_VARIANT_VARIADIC_LIMIT
#define BSLSTL_VARIANT_VARIADIC_LIMIT 18
#endif
#ifndef BSLSTL_VARIANT_VARIADIC_LIMIT_I
#define BSLSTL_VARIANT_VARIADIC_LIMIT_I BSLSTL_VARIANT_VARIADIC_LIMIT
#endif
template <class t_HEAD = void
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 0
        , class t_TAIL0_0 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 1
        , class t_TAIL0_1 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 2
        , class t_TAIL0_2 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 3
        , class t_TAIL0_3 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 4
        , class t_TAIL0_4 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 5
        , class t_TAIL0_5 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 6
        , class t_TAIL0_6 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 7
        , class t_TAIL0_7 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 8
        , class t_TAIL0_8 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 9
        , class t_TAIL0_9 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 10
        , class t_TAIL0_10 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 11
        , class t_TAIL0_11 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 12
        , class t_TAIL0_12 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 13
        , class t_TAIL0_13 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 14
        , class t_TAIL0_14 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 15
        , class t_TAIL0_15 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 16
        , class t_TAIL0_16 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 17
        , class t_TAIL0_17 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 17
        , class = BSLS_COMPILERFEATURES_NILT
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 0
        , class t_TAIL_0 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 1
        , class t_TAIL_1 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 2
        , class t_TAIL_2 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 3
        , class t_TAIL_3 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 4
        , class t_TAIL_4 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 5
        , class t_TAIL_5 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 6
        , class t_TAIL_6 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 7
        , class t_TAIL_7 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 8
        , class t_TAIL_8 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 9
        , class t_TAIL_9 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 10
        , class t_TAIL_10 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 11
        , class t_TAIL_11 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 12
        , class t_TAIL_12 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 13
        , class t_TAIL_13 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 14
        , class t_TAIL_14 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 15
        , class t_TAIL_15 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 16
        , class t_TAIL_16 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 17
        , class t_TAIL_17 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 17
        , class = BSLS_COMPILERFEATURES_NILT>
union Variant_Union;
 
 
template <>
union Variant_Union<void, void> {
};
 
template <>
union Variant_Union<BloombergLP::bsls::CompilerFeaturesNilT> {
};
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 0
template <class t_HEAD, class t_TAIL0>
union Variant_Union<t_HEAD, t_TAIL0> {
 
    Variant_DataImp<t_HEAD>           d_head;
    Variant_Union<t_TAIL0> d_tail;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 1
template <class t_HEAD, class t_TAIL0, class t_TAIL_01>
union Variant_Union<t_HEAD, t_TAIL0, t_TAIL_01> {
 
    Variant_DataImp<t_HEAD>           d_head;
    Variant_Union<t_TAIL0, t_TAIL_01> d_tail;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 2
template <class t_HEAD, class t_TAIL0, class t_TAIL_01,
                                       class t_TAIL_02>
union Variant_Union<t_HEAD, t_TAIL0, t_TAIL_01,
                                     t_TAIL_02> {
 
    Variant_DataImp<t_HEAD>           d_head;
    Variant_Union<t_TAIL0, t_TAIL_01,
                           t_TAIL_02> d_tail;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 3
template <class t_HEAD, class t_TAIL0, class t_TAIL_01,
                                       class t_TAIL_02,
                                       class t_TAIL_03>
union Variant_Union<t_HEAD, t_TAIL0, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03> {
 
    Variant_DataImp<t_HEAD>           d_head;
    Variant_Union<t_TAIL0, t_TAIL_01,
                           t_TAIL_02,
                           t_TAIL_03> d_tail;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 4
template <class t_HEAD, class t_TAIL0, class t_TAIL_01,
                                       class t_TAIL_02,
                                       class t_TAIL_03,
                                       class t_TAIL_04>
union Variant_Union<t_HEAD, t_TAIL0, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04> {
 
    Variant_DataImp<t_HEAD>           d_head;
    Variant_Union<t_TAIL0, t_TAIL_01,
                           t_TAIL_02,
                           t_TAIL_03,
                           t_TAIL_04> d_tail;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 5
template <class t_HEAD, class t_TAIL0, class t_TAIL_01,
                                       class t_TAIL_02,
                                       class t_TAIL_03,
                                       class t_TAIL_04,
                                       class t_TAIL_05>
union Variant_Union<t_HEAD, t_TAIL0, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05> {
 
    Variant_DataImp<t_HEAD>           d_head;
    Variant_Union<t_TAIL0, t_TAIL_01,
                           t_TAIL_02,
                           t_TAIL_03,
                           t_TAIL_04,
                           t_TAIL_05> d_tail;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 6
template <class t_HEAD, class t_TAIL0, class t_TAIL_01,
                                       class t_TAIL_02,
                                       class t_TAIL_03,
                                       class t_TAIL_04,
                                       class t_TAIL_05,
                                       class t_TAIL_06>
union Variant_Union<t_HEAD, t_TAIL0, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06> {
 
    Variant_DataImp<t_HEAD>           d_head;
    Variant_Union<t_TAIL0, t_TAIL_01,
                           t_TAIL_02,
                           t_TAIL_03,
                           t_TAIL_04,
                           t_TAIL_05,
                           t_TAIL_06> d_tail;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 7
template <class t_HEAD, class t_TAIL0, class t_TAIL_01,
                                       class t_TAIL_02,
                                       class t_TAIL_03,
                                       class t_TAIL_04,
                                       class t_TAIL_05,
                                       class t_TAIL_06,
                                       class t_TAIL_07>
union Variant_Union<t_HEAD, t_TAIL0, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07> {
 
    Variant_DataImp<t_HEAD>           d_head;
    Variant_Union<t_TAIL0, t_TAIL_01,
                           t_TAIL_02,
                           t_TAIL_03,
                           t_TAIL_04,
                           t_TAIL_05,
                           t_TAIL_06,
                           t_TAIL_07> d_tail;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 8
template <class t_HEAD, class t_TAIL0, class t_TAIL_01,
                                       class t_TAIL_02,
                                       class t_TAIL_03,
                                       class t_TAIL_04,
                                       class t_TAIL_05,
                                       class t_TAIL_06,
                                       class t_TAIL_07,
                                       class t_TAIL_08>
union Variant_Union<t_HEAD, t_TAIL0, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08> {
 
    Variant_DataImp<t_HEAD>           d_head;
    Variant_Union<t_TAIL0, t_TAIL_01,
                           t_TAIL_02,
                           t_TAIL_03,
                           t_TAIL_04,
                           t_TAIL_05,
                           t_TAIL_06,
                           t_TAIL_07,
                           t_TAIL_08> d_tail;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 9
template <class t_HEAD, class t_TAIL0, class t_TAIL_01,
                                       class t_TAIL_02,
                                       class t_TAIL_03,
                                       class t_TAIL_04,
                                       class t_TAIL_05,
                                       class t_TAIL_06,
                                       class t_TAIL_07,
                                       class t_TAIL_08,
                                       class t_TAIL_09>
union Variant_Union<t_HEAD, t_TAIL0, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09> {
 
    Variant_DataImp<t_HEAD>           d_head;
    Variant_Union<t_TAIL0, t_TAIL_01,
                           t_TAIL_02,
                           t_TAIL_03,
                           t_TAIL_04,
                           t_TAIL_05,
                           t_TAIL_06,
                           t_TAIL_07,
                           t_TAIL_08,
                           t_TAIL_09> d_tail;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 10
template <class t_HEAD, class t_TAIL0, class t_TAIL_01,
                                       class t_TAIL_02,
                                       class t_TAIL_03,
                                       class t_TAIL_04,
                                       class t_TAIL_05,
                                       class t_TAIL_06,
                                       class t_TAIL_07,
                                       class t_TAIL_08,
                                       class t_TAIL_09,
                                       class t_TAIL_10>
union Variant_Union<t_HEAD, t_TAIL0, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10> {
 
    Variant_DataImp<t_HEAD>           d_head;
    Variant_Union<t_TAIL0, t_TAIL_01,
                           t_TAIL_02,
                           t_TAIL_03,
                           t_TAIL_04,
                           t_TAIL_05,
                           t_TAIL_06,
                           t_TAIL_07,
                           t_TAIL_08,
                           t_TAIL_09,
                           t_TAIL_10> d_tail;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 11
template <class t_HEAD, class t_TAIL0, class t_TAIL_01,
                                       class t_TAIL_02,
                                       class t_TAIL_03,
                                       class t_TAIL_04,
                                       class t_TAIL_05,
                                       class t_TAIL_06,
                                       class t_TAIL_07,
                                       class t_TAIL_08,
                                       class t_TAIL_09,
                                       class t_TAIL_10,
                                       class t_TAIL_11>
union Variant_Union<t_HEAD, t_TAIL0, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11> {
 
    Variant_DataImp<t_HEAD>           d_head;
    Variant_Union<t_TAIL0, t_TAIL_01,
                           t_TAIL_02,
                           t_TAIL_03,
                           t_TAIL_04,
                           t_TAIL_05,
                           t_TAIL_06,
                           t_TAIL_07,
                           t_TAIL_08,
                           t_TAIL_09,
                           t_TAIL_10,
                           t_TAIL_11> d_tail;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 12
template <class t_HEAD, class t_TAIL0, class t_TAIL_01,
                                       class t_TAIL_02,
                                       class t_TAIL_03,
                                       class t_TAIL_04,
                                       class t_TAIL_05,
                                       class t_TAIL_06,
                                       class t_TAIL_07,
                                       class t_TAIL_08,
                                       class t_TAIL_09,
                                       class t_TAIL_10,
                                       class t_TAIL_11,
                                       class t_TAIL_12>
union Variant_Union<t_HEAD, t_TAIL0, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12> {
 
    Variant_DataImp<t_HEAD>           d_head;
    Variant_Union<t_TAIL0, t_TAIL_01,
                           t_TAIL_02,
                           t_TAIL_03,
                           t_TAIL_04,
                           t_TAIL_05,
                           t_TAIL_06,
                           t_TAIL_07,
                           t_TAIL_08,
                           t_TAIL_09,
                           t_TAIL_10,
                           t_TAIL_11,
                           t_TAIL_12> d_tail;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 13
template <class t_HEAD, class t_TAIL0, class t_TAIL_01,
                                       class t_TAIL_02,
                                       class t_TAIL_03,
                                       class t_TAIL_04,
                                       class t_TAIL_05,
                                       class t_TAIL_06,
                                       class t_TAIL_07,
                                       class t_TAIL_08,
                                       class t_TAIL_09,
                                       class t_TAIL_10,
                                       class t_TAIL_11,
                                       class t_TAIL_12,
                                       class t_TAIL_13>
union Variant_Union<t_HEAD, t_TAIL0, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13> {
 
    Variant_DataImp<t_HEAD>           d_head;
    Variant_Union<t_TAIL0, t_TAIL_01,
                           t_TAIL_02,
                           t_TAIL_03,
                           t_TAIL_04,
                           t_TAIL_05,
                           t_TAIL_06,
                           t_TAIL_07,
                           t_TAIL_08,
                           t_TAIL_09,
                           t_TAIL_10,
                           t_TAIL_11,
                           t_TAIL_12,
                           t_TAIL_13> d_tail;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 14
template <class t_HEAD, class t_TAIL0, class t_TAIL_01,
                                       class t_TAIL_02,
                                       class t_TAIL_03,
                                       class t_TAIL_04,
                                       class t_TAIL_05,
                                       class t_TAIL_06,
                                       class t_TAIL_07,
                                       class t_TAIL_08,
                                       class t_TAIL_09,
                                       class t_TAIL_10,
                                       class t_TAIL_11,
                                       class t_TAIL_12,
                                       class t_TAIL_13,
                                       class t_TAIL_14>
union Variant_Union<t_HEAD, t_TAIL0, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14> {
 
    Variant_DataImp<t_HEAD>           d_head;
    Variant_Union<t_TAIL0, t_TAIL_01,
                           t_TAIL_02,
                           t_TAIL_03,
                           t_TAIL_04,
                           t_TAIL_05,
                           t_TAIL_06,
                           t_TAIL_07,
                           t_TAIL_08,
                           t_TAIL_09,
                           t_TAIL_10,
                           t_TAIL_11,
                           t_TAIL_12,
                           t_TAIL_13,
                           t_TAIL_14> d_tail;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 15
template <class t_HEAD, class t_TAIL0, class t_TAIL_01,
                                       class t_TAIL_02,
                                       class t_TAIL_03,
                                       class t_TAIL_04,
                                       class t_TAIL_05,
                                       class t_TAIL_06,
                                       class t_TAIL_07,
                                       class t_TAIL_08,
                                       class t_TAIL_09,
                                       class t_TAIL_10,
                                       class t_TAIL_11,
                                       class t_TAIL_12,
                                       class t_TAIL_13,
                                       class t_TAIL_14,
                                       class t_TAIL_15>
union Variant_Union<t_HEAD, t_TAIL0, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14,
                                     t_TAIL_15> {
 
    Variant_DataImp<t_HEAD>           d_head;
    Variant_Union<t_TAIL0, t_TAIL_01,
                           t_TAIL_02,
                           t_TAIL_03,
                           t_TAIL_04,
                           t_TAIL_05,
                           t_TAIL_06,
                           t_TAIL_07,
                           t_TAIL_08,
                           t_TAIL_09,
                           t_TAIL_10,
                           t_TAIL_11,
                           t_TAIL_12,
                           t_TAIL_13,
                           t_TAIL_14,
                           t_TAIL_15> d_tail;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 16
template <class t_HEAD, class t_TAIL0, class t_TAIL_01,
                                       class t_TAIL_02,
                                       class t_TAIL_03,
                                       class t_TAIL_04,
                                       class t_TAIL_05,
                                       class t_TAIL_06,
                                       class t_TAIL_07,
                                       class t_TAIL_08,
                                       class t_TAIL_09,
                                       class t_TAIL_10,
                                       class t_TAIL_11,
                                       class t_TAIL_12,
                                       class t_TAIL_13,
                                       class t_TAIL_14,
                                       class t_TAIL_15,
                                       class t_TAIL_16>
union Variant_Union<t_HEAD, t_TAIL0, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14,
                                     t_TAIL_15,
                                     t_TAIL_16> {
 
    Variant_DataImp<t_HEAD>           d_head;
    Variant_Union<t_TAIL0, t_TAIL_01,
                           t_TAIL_02,
                           t_TAIL_03,
                           t_TAIL_04,
                           t_TAIL_05,
                           t_TAIL_06,
                           t_TAIL_07,
                           t_TAIL_08,
                           t_TAIL_09,
                           t_TAIL_10,
                           t_TAIL_11,
                           t_TAIL_12,
                           t_TAIL_13,
                           t_TAIL_14,
                           t_TAIL_15,
                           t_TAIL_16> d_tail;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 17
template <class t_HEAD, class t_TAIL0, class t_TAIL_01,
                                       class t_TAIL_02,
                                       class t_TAIL_03,
                                       class t_TAIL_04,
                                       class t_TAIL_05,
                                       class t_TAIL_06,
                                       class t_TAIL_07,
                                       class t_TAIL_08,
                                       class t_TAIL_09,
                                       class t_TAIL_10,
                                       class t_TAIL_11,
                                       class t_TAIL_12,
                                       class t_TAIL_13,
                                       class t_TAIL_14,
                                       class t_TAIL_15,
                                       class t_TAIL_16,
                                       class t_TAIL_17>
union Variant_Union<t_HEAD, t_TAIL0, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14,
                                     t_TAIL_15,
                                     t_TAIL_16,
                                     t_TAIL_17> {
 
    Variant_DataImp<t_HEAD>           d_head;
    Variant_Union<t_TAIL0, t_TAIL_01,
                           t_TAIL_02,
                           t_TAIL_03,
                           t_TAIL_04,
                           t_TAIL_05,
                           t_TAIL_06,
                           t_TAIL_07,
                           t_TAIL_08,
                           t_TAIL_09,
                           t_TAIL_10,
                           t_TAIL_11,
                           t_TAIL_12,
                           t_TAIL_13,
                           t_TAIL_14,
                           t_TAIL_15,
                           t_TAIL_16,
                           t_TAIL_17> d_tail;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 18
template <class t_HEAD, class t_TAIL0, class t_TAIL_01,
                                       class t_TAIL_02,
                                       class t_TAIL_03,
                                       class t_TAIL_04,
                                       class t_TAIL_05,
                                       class t_TAIL_06,
                                       class t_TAIL_07,
                                       class t_TAIL_08,
                                       class t_TAIL_09,
                                       class t_TAIL_10,
                                       class t_TAIL_11,
                                       class t_TAIL_12,
                                       class t_TAIL_13,
                                       class t_TAIL_14,
                                       class t_TAIL_15,
                                       class t_TAIL_16,
                                       class t_TAIL_17,
                                       class t_TAIL_18>
union Variant_Union<t_HEAD, t_TAIL0, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14,
                                     t_TAIL_15,
                                     t_TAIL_16,
                                     t_TAIL_17,
                                     t_TAIL_18> {
 
    Variant_DataImp<t_HEAD>           d_head;
    Variant_Union<t_TAIL0, t_TAIL_01,
                           t_TAIL_02,
                           t_TAIL_03,
                           t_TAIL_04,
                           t_TAIL_05,
                           t_TAIL_06,
                           t_TAIL_07,
                           t_TAIL_08,
                           t_TAIL_09,
                           t_TAIL_10,
                           t_TAIL_11,
                           t_TAIL_12,
                           t_TAIL_13,
                           t_TAIL_14,
                           t_TAIL_15,
                           t_TAIL_16,
                           t_TAIL_17,
                           t_TAIL_18> d_tail;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 18
 
#else
// The generated code below is a workaround for the absence of perfect
// forwarding in some compilers.
template <class t_HEAD = void, class... t_TAIL0 = void, class... t_TAIL>
union Variant_Union;
 
template <>
union Variant_Union<void, void> {
};
 
template <>
union Variant_Union<BloombergLP::bsls::CompilerFeaturesNilT> {
};
 
template <class t_HEAD, class t_TAIL0, class... t_TAIL>
union Variant_Union<t_HEAD, t_TAIL0, t_TAIL...> {
 
    Variant_DataImp<t_HEAD>           d_head;
    Variant_Union<t_TAIL0, t_TAIL...> d_tail;
};
// }}} END GENERATED CODE
#endif
#endif  // BSL_VARIANT_FULL_IMPLEMENTATION
 
                     // ==================================
                     // class Variant_CopyConstructVisitor
                     // ==================================
 
/// This component-private class is a visitor that is used to implement the
/// copy constructor for `bsl::variant`.
///
/// See @ref bslstl_variant_cpp03 
template <class t_VARIANT_BASE>
class Variant_CopyConstructVisitor {
 
  private:
    // DATA
    t_VARIANT_BASE *d_variant_p;
 
  public:
    // CREATORS
    explicit Variant_CopyConstructVisitor(t_VARIANT_BASE *variant)
    // Create a 'Variant_CopyConstructVisitor' object that, when invoked,
    // will copy-construct an alternative in the specified 'variant'.
    : d_variant_p(variant)
    {
        BSLS_ASSERT_SAFE(d_variant_p);
    }
 
    // ACCESSORS
 
    /// Copy-construct the alternative at index (template parameter)
    /// `t_INDEX` from the specified `other` (i.e. the alternative that is
    /// being visited).  Note that the allocator specified on construction
    /// of `*d_variant_p` will be used.
    template <size_t t_INDEX, class t_TYPE>
    void operator()(bsl::in_place_index_t<t_INDEX>, const t_TYPE& other) const
    {
        d_variant_p->template baseEmplace<t_INDEX>(other);
    }
};
 
                     // ==================================
                     // class Variant_MoveConstructVisitor
                     // ==================================
 
/// This component-private class is a visitor that is used to implement the
/// move constructor for `bsl::variant`.
///
/// See @ref bslstl_variant_cpp03 
template <class t_VARIANT_BASE>
class Variant_MoveConstructVisitor {
 
  private:
    // PRIVATE TYPES
    typedef BloombergLP::bslmf::MovableRefUtil MoveUtil;
 
    // DATA
    t_VARIANT_BASE *d_variant_p;
 
  public:
    // CREATORS
 
    /// Create a `Variant_MoveConstructVisitor` object that, when invoked,
    /// will move-construct an alternative in the specified `variant`.
    explicit Variant_MoveConstructVisitor(t_VARIANT_BASE *variant)
    : d_variant_p(variant)
    {
        BSLS_ASSERT_SAFE(d_variant_p);
    }
 
    // ACCESSORS
 
    /// Move-construct the alternative at index (template parameter)
    /// `t_INDEX` from the specified `other` (i.e. the alternative that is
    /// being visited).  Note that the allocator specified on construction
    /// of `*d_variant_p` will be used.
    template <size_t t_INDEX, class t_TYPE>
    void operator()(bsl::in_place_index_t<t_INDEX>, t_TYPE& other) const
    {
        d_variant_p->template baseEmplace<t_INDEX>(MoveUtil::move(other));
    }
};
 
                      // ===============================
                      // class Variant_CopyAssignVisitor
                      // ===============================
 
/// This component-private class is a visitor that is used to implement the
/// copy assignment operator for `bsl::variant`.
///
/// See @ref bslstl_variant_cpp03 
template <class t_VARIANT>
class Variant_CopyAssignVisitor {
 
  private:
    // DATA
    t_VARIANT *d_variant_p;
 
  public:
    // CREATORS
 
    /// Create a `Variant_CopyAssignVisitor` object that, when invoked, will
    /// copy-assign to the active alternative of the specified `variant`.
    explicit Variant_CopyAssignVisitor(t_VARIANT *variant)
    : d_variant_p(variant)
    {
        BSLS_ASSERT_SAFE(d_variant_p);
    }
 
 
  public:
    // ACCESSORS
 
    /// Copy-assign to the active alternative of `*d_variant_p` from the
    /// specified `value` (i.e. the alternative that is being visited).  The
    /// behavior is undefined unless (template parameter) `t_INDEX` is the
    /// index of the active alternative of `*d_variant_p` (or, in C++03, the
    /// index of an alternative that has the same type as the active
    /// alternative).
    template <size_t t_INDEX, class t_TYPE>
    void operator()(bsl::in_place_index_t<t_INDEX>, const t_TYPE& value) const
    {
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
        bsl::get<t_INDEX>(*d_variant_p) = value;
#else
        // When invoking this visitor in C++03, 't_INDEX' may not be the index
        // of the active alternative, but it will be an index of an alternative
        // of same type.  However, because 't_TYPE' is deduced, it may be
        // missing cv-qualifications.  't_ALT_TYPE' will give the correct
        // cv-qualification.
        typedef typename bsl::variant_alternative<t_INDEX, t_VARIANT>::type
                                                     Alt_Type;
        typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
        ImpUtil::unsafeGet<Alt_Type>(*d_variant_p) = value;
#endif  // BSL_VARIANT_FULL_IMPLEMENTATION
    }
};
 
                      // ===============================
                      // class Variant_MoveAssignVisitor
                      // ===============================
 
/// This component-private class is a visitor that is used to implement the
/// move assignment operator for `bsl::variant`.
///
/// See @ref bslstl_variant_cpp03 
template <class t_VARIANT>
class Variant_MoveAssignVisitor {
 
  private:
    // PRIVATE TYPES
    typedef BloombergLP::bslmf::MovableRefUtil MoveUtil;
 
    // DATA
    t_VARIANT *d_variant_p;
 
  public:
    // CREATORS
 
    /// Create a `Variant_MoveAssignVisitor` object that, when invoked, will
    /// move-assign to the active alternative of the specified `variant`.
    explicit Variant_MoveAssignVisitor(t_VARIANT *variant)
    : d_variant_p(variant)
    {
        BSLS_ASSERT_SAFE(d_variant_p);
    }
 
  public:
    // ACCESSORS
 
    /// Move-assign to the active alternative of `*d_variant_p` from the
    /// specified `value` (i.e. the alternative that is being visited).  The
    /// behavior is undefined unless (template parameter) `t_INDEX` is the
    /// index of the active alternative of `*d_variant_p` (or, in C++03, the
    /// index of an alternative that has the same type as the active
    /// alternative).
    template <size_t t_INDEX, class t_TYPE>
    void operator()(bsl::in_place_index_t<t_INDEX>, t_TYPE& value) const
    {
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
        bsl::get<t_INDEX>(*d_variant_p) = MoveUtil::move(value);
#else
        typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
        ImpUtil::unsafeGet<t_TYPE>(*d_variant_p) = MoveUtil::move(value);
#endif  // BSL_VARIANT_FULL_IMPLEMENTATION
    }
};
 
                      // ================================
                      // struct Variant_DestructorVisitor
                      // ================================
 
/// This component-private struct is a visitor that destroys the active
/// alternative of the visited `variant` object.
struct Variant_DestructorVisitor {
 
  public:
    // ACCESSORS
 
    /// Destroy the specified `object`, which is the alternative that is
    /// being visited.
    template <class t_TYPE>
    void operator()(t_TYPE& object) const
    {
        bslma::DestructionUtil::destroy(&object);
    }
};
 
                       // ==============================
                       // struct Variant_##NAME##Visitor
                       // ==============================
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
#define BSLSTL_VARIANT_RELOP_VISITOR_DEFINITON(NAME, OP)                      \
    template <class t_VARIANT>                                                \
    struct Variant_##NAME##Visitor {                                          \
        /*  When using this visitor, construct the visitor using the left  */ \
        /*  operand, and call visitation on the right operand.             */ \
        explicit Variant_##NAME##Visitor(const t_VARIANT *variant)            \
        : d_variant_p(variant)                                                \
        {                                                                     \
            BSLS_ASSERT_SAFE(d_variant_p);                                    \
        }                                                                     \
                                                                              \
      private:                                                                \
        const t_VARIANT *d_variant_p;                                         \
                                                                              \
      public:                                                                 \
        template <size_t t_INDEX, class t_TYPE>                               \
        bool operator()(bsl::in_place_index_t<t_INDEX>,                       \
                        const t_TYPE&                  value) const           \
        {                                                                     \
            return (bsl::get<t_INDEX>(*d_variant_p) OP value);                \
        }                                                                     \
    };                                                                        \
                                                                              \
    template <class t_VARIANT>                                                \
    bool Variant_ImpUtil::NAME(const t_VARIANT& lhs, const t_VARIANT& rhs)    \
    {                                                                         \
        BSLS_ASSERT(lhs.index() == rhs.index() &&                             \
                    !lhs.valueless_by_exception());                           \
                                                                              \
        Variant_##NAME##Visitor<t_VARIANT> NAME##Visitor(                     \
                                                   BSLS_UTIL_ADDRESSOF(lhs)); \
        return BSLSTL_VARIANT_VISITID(bool, NAME##Visitor, rhs);              \
    }
#else
#define BSLSTL_VARIANT_RELOP_VISITOR_DEFINITON(NAME, OP)                      \
    template <class t_VARIANT>                                                \
    struct Variant_##NAME##Visitor {                                          \
        Variant_##NAME##Visitor(const t_VARIANT *variant)                     \
        : d_variant_p(variant)                                                \
        {                                                                     \
            BSLS_ASSERT_SAFE(d_variant_p);                                    \
        }                                                                     \
                                                                              \
      private:                                                                \
        const t_VARIANT *d_variant_p;                                         \
                                                                              \
      public:                                                                 \
        template <size_t t_INDEX, class t_TYPE>                               \
        bool operator()(bsl::in_place_index_t<t_INDEX>,                       \
                        t_TYPE&                  value) const                 \
        {                                                                     \
            /* When invoking this visitor in C++03, 't_INDEX' may not be   */ \
            /* the index of the active alternative, but it will be an      */ \
            /* index of an alternative of same type.  However, because     */ \
            /* 't_TYPE' is deduced, it may have incorrect                  */ \
            /* cv-qualifications.  't_ALT_TYPE' will give the correct      */ \
            /* cv-qualification.                                           */ \
            typedef                                                           \
                typename bsl::variant_alternative<t_INDEX, t_VARIANT>::type   \
                                                                    Alt_Type; \
            typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;             \
            return (ImpUtil::unsafeGet<Alt_Type>(*d_variant_p) OP value);     \
        }                                                                     \
    };                                                                        \
                                                                              \
    template <class t_VARIANT>                                                \
    bool Variant_ImpUtil::NAME(const t_VARIANT& lhs, const t_VARIANT& rhs)    \
    {                                                                         \
        BSLS_ASSERT(lhs.index() == rhs.index() &&                             \
                    !lhs.valueless_by_exception());                           \
                                                                              \
        Variant_##NAME##Visitor<t_VARIANT> NAME##Visitor(                     \
                                                   BSLS_UTIL_ADDRESSOF(lhs)); \
        return BSLSTL_VARIANT_VISITID(bool, NAME##Visitor, rhs);              \
    }
#endif  // BSL_VARIANT_FULL_IMPLEMENTATION
    // This macro is used to define the 'Variant_ImpUtil::*Impl' methods.
 
BSLSTL_VARIANT_RELOP_VISITOR_DEFINITON(Equal, ==)
BSLSTL_VARIANT_RELOP_VISITOR_DEFINITON(NotEqual, !=)
BSLSTL_VARIANT_RELOP_VISITOR_DEFINITON(LessThan, <)
BSLSTL_VARIANT_RELOP_VISITOR_DEFINITON(GreaterThan, >)
BSLSTL_VARIANT_RELOP_VISITOR_DEFINITON(LessOrEqual, <=)
BSLSTL_VARIANT_RELOP_VISITOR_DEFINITON(GreaterOrEqual, >=)
 
                         // =========================
                         // class Variant_SwapVisitor
                         // =========================
 
/// This component-private class is a visitor that is used to implement
/// `bsl::variant::swap`.
///
/// See @ref bslstl_variant_cpp03 
template <class t_VARIANT>
class Variant_SwapVisitor {
 
  private:
    // DATA
    t_VARIANT *d_variant_p;
 
  public:
    // CREATORS
 
    /// Create a `Variant_SwapVisitor` object that, when invoked, will swap
    /// the visited alternative with the active alternative of the specified
    /// `variant`.
    explicit Variant_SwapVisitor(t_VARIANT *variant)
    : d_variant_p(variant)
    {
        BSLS_ASSERT_SAFE(d_variant_p);
    }
 
    // ACCESSORS
 
    /// Swap the alternative having index (template parameter) `t_INDEX` in
    /// `*d_variant_p` with the specified `value` (i.e. the alternative that
    /// is being visited).  The behavior is undefined unless `t_INDEX` is the
    /// index of the active alternative of `*d_variant_p` (or, in C++03, the
    /// index of an alternative that has the same type as the active
    /// alternative).
    template <size_t t_INDEX, class t_TYPE>
    void operator()(bsl::in_place_index_t<t_INDEX>, t_TYPE& value) const
    {
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
        BloombergLP::bslalg::SwapUtil::swap(
                         BSLS_UTIL_ADDRESSOF(value),
                         BSLS_UTIL_ADDRESSOF(bsl::get<t_INDEX>(*d_variant_p)));
#else
        typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
            // When invoking this visitor in C++03, 't_INDEX' may not be the
            // index of the active alternative, but it will be an index of an
            // alternative of same type. Swap can not be invoked on a constant
            // variant, so the cv qualifications will match.
        BloombergLP::bslalg::SwapUtil::swap(
              BSLS_UTIL_ADDRESSOF(value),
              BSLS_UTIL_ADDRESSOF((ImpUtil::unsafeGet<t_TYPE>(*d_variant_p))));
#endif  // BSL_VARIANT_FULL_IMPLEMENTATION
    }
};
 
                         // =========================
                         // class Variant_HashVisitor
                         // =========================
 
/// This component-private class is a visitor that is used to implement
/// `hashAppend` for `bsl::variant`.
///
/// See @ref bslstl_variant_cpp03 
template <class t_HASHALG>
class Variant_HashVisitor {
 
  private:
    // DATA
    t_HASHALG& d_hashAlg;
 
  public:
    // CREATORS
 
    /// Create a `Variant_HashVisitor` object that, when invoked, appends to
    /// the specified `hashAlg`.
    explicit Variant_HashVisitor(t_HASHALG& hashAlg)
    : d_hashAlg(hashAlg)
    {
    }
 
    // ACCESSORS
 
    /// Append the specified `value` (i.e., the alternative that is being
    /// visited) to `d_hashAlg`.
    template <class t_TYPE>
    void operator()(t_TYPE& value) const
    {
        using BloombergLP::bslh::hashAppend;
        hashAppend(d_hashAlg, value);
    }
};
 
/// This component-private struct keeps track of the allocator for a
/// `bsl::variant` object.  The primary template is used when the `variant`
/// is not allocator-aware (because it has no allocator-aware alternatives).
template <bool t_AA>
struct Variant_AllocatorBase {
 
    // ACCESSORS
 
    /// Return a null pointer.  Note that this method has the same return
    /// type as the allocator-aware version so that the remainder of the
    /// implementation of `bsl::variant` is abstracted with respect to
    /// whether or not the specialization is allocator-aware; this is why
    /// both methods return `bslma::Allocator*` instead of
    /// `bsl::allocator<char>`.  The returned pointer will be ignored (and
    /// not dereferenced) when passed to
    /// `bslma::ConstructionUtil::construct`.
    BloombergLP::bslma::Allocator *mechanism() const
    {
        return NULL;
    }
};
 
/// This specialization is used when the `variant` is allocator-aware.
template <>
struct Variant_AllocatorBase<true> {
 
    // TYPES
    typedef BloombergLP::bslmf::MovableRefUtil MoveUtil;
    typedef bsl::allocator<char>               allocator_type;
 
    // PUBLIC DATA
    allocator_type d_allocator;
 
    // CREATORS
 
    /// Create a `Variant_AllocatorBase` object that holds the currently
    /// installed default allocator.
    Variant_AllocatorBase() {}
 
    /// Create a `Variant_AllocatorBase` object that holds a copy of the
    /// allocator held by the specified `original`.
    Variant_AllocatorBase(const Variant_AllocatorBase& original)
    : d_allocator(original.d_allocator)
    {
    }
 
    /// Create a `Variant_AllocatorBase` object that holds a copy of the
    /// specified `allocator`.
    Variant_AllocatorBase(allocator_type allocator)
    : d_allocator(allocator)
    {
    }
 
    // ACCESSORS
 
    /// Return the mechanism of the stored allocator.
    BloombergLP::bslma::Allocator *mechanism() const
    {
        return d_allocator.mechanism();
    }
};
 
                            // ===================
                            // struct variant_base
                            // ===================
 
#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
// {{{ BEGIN GENERATED CODE
// Command line: sim_cpp11_features.pl bslstl_variant.h
#ifndef BSLSTL_VARIANT_VARIADIC_LIMIT
#define BSLSTL_VARIANT_VARIADIC_LIMIT 18
#endif
#ifndef BSLSTL_VARIANT_VARIADIC_LIMIT_J
#define BSLSTL_VARIANT_VARIADIC_LIMIT_J BSLSTL_VARIANT_VARIADIC_LIMIT
#endif
template <class t_HEAD
#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 0
        , class t_TAIL_0 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 1
        , class t_TAIL_1 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 2
        , class t_TAIL_2 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 3
        , class t_TAIL_3 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 4
        , class t_TAIL_4 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 5
        , class t_TAIL_5 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 6
        , class t_TAIL_6 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 7
        , class t_TAIL_7 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 8
        , class t_TAIL_8 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 9
        , class t_TAIL_9 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 10
        , class t_TAIL_10 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 11
        , class t_TAIL_11 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 12
        , class t_TAIL_12 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 13
        , class t_TAIL_13 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 14
        , class t_TAIL_14 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 15
        , class t_TAIL_15 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 16
        , class t_TAIL_16 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 17
        , class t_TAIL_17 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 17
        , class = BSLS_COMPILERFEATURES_NILT>
struct Variant_Base;
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 0
template <class t_HEAD>
struct Variant_Base<t_HEAD>
: public BloombergLP::bslstl::Variant_AllocatorBase<
      BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD>::value> {
 
    typedef BloombergLP::bslmf::MovableRefUtil MoveUtil;
    typedef BloombergLP::bslstl::Variant_AllocatorBase<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD>::value>
        AllocBase;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD>
                                            Variant_Union;
    typedef bsl::variant<t_HEAD> Variant;
 
    struct NoAlloc {
    };
 
    typedef typename bsl::conditional<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD>::value,
        bsl::allocator<char>,
        NoAlloc>::type allocator_type;
 
 
    size_t        d_type;
 
    Variant_Union d_union;
 
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD>::value));
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    Variant_Base();
 
    Variant_Base(const Variant_Base& original);
 
    Variant_Base(Variant_Base&& original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(Variant_ConstructFromStdTag, size_t index);
#endif
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>);
 
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 Variant&&            original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type allocator,
                 Variant_ConstructFromStdTag,
                 size_t         index);
#endif
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>);
 
#else
 
    Variant_Base();
 
    Variant_Base(const Variant& original);
 
    Variant_Base(BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type                          allocator,
                 BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
#endif
 
    ~Variant_Base();
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <size_t t_INDEX>
    void baseEmplace();
#else
    template <size_t t_INDEX>
    void baseEmplace();
    template <size_t t_INDEX, class t_ARG_01>
    void baseEmplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    void baseEmplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
#endif
 
    Variant_Base& operator=(const Variant_Base& rhs);
 
    Variant_Base& operator=(BloombergLP::bslmf::MovableRef<Variant_Base> rhs);
 
    void reset() BSLS_KEYWORD_NOEXCEPT;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 1
template <class t_HEAD, class t_TAIL_01>
struct Variant_Base<t_HEAD, t_TAIL_01>
: public BloombergLP::bslstl::Variant_AllocatorBase<
      BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                         t_TAIL_01>::value> {
 
    typedef BloombergLP::bslmf::MovableRefUtil MoveUtil;
    typedef BloombergLP::bslstl::Variant_AllocatorBase<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                           t_TAIL_01>::value>
        AllocBase;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD, t_TAIL_01>
                                            Variant_Union;
    typedef bsl::variant<t_HEAD, t_TAIL_01> Variant;
 
    struct NoAlloc {
    };
 
    typedef typename bsl::conditional<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                           t_TAIL_01>::value,
        bsl::allocator<char>,
        NoAlloc>::type allocator_type;
 
 
    size_t        d_type;
 
    Variant_Union d_union;
 
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD,
                                                           t_TAIL_01>::value));
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    Variant_Base();
 
    Variant_Base(const Variant_Base& original);
 
    Variant_Base(Variant_Base&& original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(Variant_ConstructFromStdTag, size_t index);
#endif
 
    template <size_t t_INDEX, class t_ARGS_01>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01);
 
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 Variant&&            original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type allocator,
                 Variant_ConstructFromStdTag,
                 size_t         index);
#endif
 
    template <size_t t_INDEX, class t_ARGS_01>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01);
 
#else
 
    Variant_Base();
 
    Variant_Base(const Variant& original);
 
    Variant_Base(BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type                          allocator,
                 BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
#endif
 
    ~Variant_Base();
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <size_t t_INDEX, class t_ARGS_01>
    void baseEmplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01));
#else
    template <size_t t_INDEX>
    void baseEmplace();
    template <size_t t_INDEX, class t_ARG_01>
    void baseEmplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    void baseEmplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
#endif
 
    Variant_Base& operator=(const Variant_Base& rhs);
 
    Variant_Base& operator=(BloombergLP::bslmf::MovableRef<Variant_Base> rhs);
 
    void reset() BSLS_KEYWORD_NOEXCEPT;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
struct Variant_Base<t_HEAD, t_TAIL_01,
                            t_TAIL_02>
: public BloombergLP::bslstl::Variant_AllocatorBase<
      BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                         t_TAIL_01,
                                                         t_TAIL_02>::value> {
 
    typedef BloombergLP::bslmf::MovableRefUtil MoveUtil;
    typedef BloombergLP::bslstl::Variant_AllocatorBase<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02>::value>
        AllocBase;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02>
                                            Variant_Union;
    typedef bsl::variant<t_HEAD, t_TAIL_01,
                                 t_TAIL_02> Variant;
 
    struct NoAlloc {
    };
 
    typedef typename bsl::conditional<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02>::value,
        bsl::allocator<char>,
        NoAlloc>::type allocator_type;
 
 
    size_t        d_type;
 
    Variant_Union d_union;
 
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02>::value));
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    Variant_Base();
 
    Variant_Base(const Variant_Base& original);
 
    Variant_Base(Variant_Base&& original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(Variant_ConstructFromStdTag, size_t index);
#endif
 
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02);
 
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 Variant&&            original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type allocator,
                 Variant_ConstructFromStdTag,
                 size_t         index);
#endif
 
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02);
 
#else
 
    Variant_Base();
 
    Variant_Base(const Variant& original);
 
    Variant_Base(BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type                          allocator,
                 BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
#endif
 
    ~Variant_Base();
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02>
    void baseEmplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02));
#else
    template <size_t t_INDEX>
    void baseEmplace();
    template <size_t t_INDEX, class t_ARG_01>
    void baseEmplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    void baseEmplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
#endif
 
    Variant_Base& operator=(const Variant_Base& rhs);
 
    Variant_Base& operator=(BloombergLP::bslmf::MovableRef<Variant_Base> rhs);
 
    void reset() BSLS_KEYWORD_NOEXCEPT;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
struct Variant_Base<t_HEAD, t_TAIL_01,
                            t_TAIL_02,
                            t_TAIL_03>
: public BloombergLP::bslstl::Variant_AllocatorBase<
      BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                         t_TAIL_01,
                                                         t_TAIL_02,
                                                         t_TAIL_03>::value> {
 
    typedef BloombergLP::bslmf::MovableRefUtil MoveUtil;
    typedef BloombergLP::bslstl::Variant_AllocatorBase<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03>::value>
        AllocBase;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03>
                                            Variant_Union;
    typedef bsl::variant<t_HEAD, t_TAIL_01,
                                 t_TAIL_02,
                                 t_TAIL_03> Variant;
 
    struct NoAlloc {
    };
 
    typedef typename bsl::conditional<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03>::value,
        bsl::allocator<char>,
        NoAlloc>::type allocator_type;
 
 
    size_t        d_type;
 
    Variant_Union d_union;
 
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03>::value));
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    Variant_Base();
 
    Variant_Base(const Variant_Base& original);
 
    Variant_Base(Variant_Base&& original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(Variant_ConstructFromStdTag, size_t index);
#endif
 
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03);
 
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 Variant&&            original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type allocator,
                 Variant_ConstructFromStdTag,
                 size_t         index);
#endif
 
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03);
 
#else
 
    Variant_Base();
 
    Variant_Base(const Variant& original);
 
    Variant_Base(BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type                          allocator,
                 BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
#endif
 
    ~Variant_Base();
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03>
    void baseEmplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03));
#else
    template <size_t t_INDEX>
    void baseEmplace();
    template <size_t t_INDEX, class t_ARG_01>
    void baseEmplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    void baseEmplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
#endif
 
    Variant_Base& operator=(const Variant_Base& rhs);
 
    Variant_Base& operator=(BloombergLP::bslmf::MovableRef<Variant_Base> rhs);
 
    void reset() BSLS_KEYWORD_NOEXCEPT;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
struct Variant_Base<t_HEAD, t_TAIL_01,
                            t_TAIL_02,
                            t_TAIL_03,
                            t_TAIL_04>
: public BloombergLP::bslstl::Variant_AllocatorBase<
      BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                         t_TAIL_01,
                                                         t_TAIL_02,
                                                         t_TAIL_03,
                                                         t_TAIL_04>::value> {
 
    typedef BloombergLP::bslmf::MovableRefUtil MoveUtil;
    typedef BloombergLP::bslstl::Variant_AllocatorBase<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04>::value>
        AllocBase;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04>
                                            Variant_Union;
    typedef bsl::variant<t_HEAD, t_TAIL_01,
                                 t_TAIL_02,
                                 t_TAIL_03,
                                 t_TAIL_04> Variant;
 
    struct NoAlloc {
    };
 
    typedef typename bsl::conditional<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04>::value,
        bsl::allocator<char>,
        NoAlloc>::type allocator_type;
 
 
    size_t        d_type;
 
    Variant_Union d_union;
 
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04>::value));
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    Variant_Base();
 
    Variant_Base(const Variant_Base& original);
 
    Variant_Base(Variant_Base&& original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(Variant_ConstructFromStdTag, size_t index);
#endif
 
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04);
 
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 Variant&&            original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type allocator,
                 Variant_ConstructFromStdTag,
                 size_t         index);
#endif
 
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04);
 
#else
 
    Variant_Base();
 
    Variant_Base(const Variant& original);
 
    Variant_Base(BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type                          allocator,
                 BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
#endif
 
    ~Variant_Base();
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04>
    void baseEmplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04));
#else
    template <size_t t_INDEX>
    void baseEmplace();
    template <size_t t_INDEX, class t_ARG_01>
    void baseEmplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    void baseEmplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
#endif
 
    Variant_Base& operator=(const Variant_Base& rhs);
 
    Variant_Base& operator=(BloombergLP::bslmf::MovableRef<Variant_Base> rhs);
 
    void reset() BSLS_KEYWORD_NOEXCEPT;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
struct Variant_Base<t_HEAD, t_TAIL_01,
                            t_TAIL_02,
                            t_TAIL_03,
                            t_TAIL_04,
                            t_TAIL_05>
: public BloombergLP::bslstl::Variant_AllocatorBase<
      BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                         t_TAIL_01,
                                                         t_TAIL_02,
                                                         t_TAIL_03,
                                                         t_TAIL_04,
                                                         t_TAIL_05>::value> {
 
    typedef BloombergLP::bslmf::MovableRefUtil MoveUtil;
    typedef BloombergLP::bslstl::Variant_AllocatorBase<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05>::value>
        AllocBase;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05>
                                            Variant_Union;
    typedef bsl::variant<t_HEAD, t_TAIL_01,
                                 t_TAIL_02,
                                 t_TAIL_03,
                                 t_TAIL_04,
                                 t_TAIL_05> Variant;
 
    struct NoAlloc {
    };
 
    typedef typename bsl::conditional<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05>::value,
        bsl::allocator<char>,
        NoAlloc>::type allocator_type;
 
 
    size_t        d_type;
 
    Variant_Union d_union;
 
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05>::value));
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    Variant_Base();
 
    Variant_Base(const Variant_Base& original);
 
    Variant_Base(Variant_Base&& original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(Variant_ConstructFromStdTag, size_t index);
#endif
 
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05);
 
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 Variant&&            original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type allocator,
                 Variant_ConstructFromStdTag,
                 size_t         index);
#endif
 
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05);
 
#else
 
    Variant_Base();
 
    Variant_Base(const Variant& original);
 
    Variant_Base(BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type                          allocator,
                 BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
#endif
 
    ~Variant_Base();
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05>
    void baseEmplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05));
#else
    template <size_t t_INDEX>
    void baseEmplace();
    template <size_t t_INDEX, class t_ARG_01>
    void baseEmplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    void baseEmplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
#endif
 
    Variant_Base& operator=(const Variant_Base& rhs);
 
    Variant_Base& operator=(BloombergLP::bslmf::MovableRef<Variant_Base> rhs);
 
    void reset() BSLS_KEYWORD_NOEXCEPT;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
struct Variant_Base<t_HEAD, t_TAIL_01,
                            t_TAIL_02,
                            t_TAIL_03,
                            t_TAIL_04,
                            t_TAIL_05,
                            t_TAIL_06>
: public BloombergLP::bslstl::Variant_AllocatorBase<
      BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                         t_TAIL_01,
                                                         t_TAIL_02,
                                                         t_TAIL_03,
                                                         t_TAIL_04,
                                                         t_TAIL_05,
                                                         t_TAIL_06>::value> {
 
    typedef BloombergLP::bslmf::MovableRefUtil MoveUtil;
    typedef BloombergLP::bslstl::Variant_AllocatorBase<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06>::value>
        AllocBase;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06>
                                            Variant_Union;
    typedef bsl::variant<t_HEAD, t_TAIL_01,
                                 t_TAIL_02,
                                 t_TAIL_03,
                                 t_TAIL_04,
                                 t_TAIL_05,
                                 t_TAIL_06> Variant;
 
    struct NoAlloc {
    };
 
    typedef typename bsl::conditional<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06>::value,
        bsl::allocator<char>,
        NoAlloc>::type allocator_type;
 
 
    size_t        d_type;
 
    Variant_Union d_union;
 
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06>::value));
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    Variant_Base();
 
    Variant_Base(const Variant_Base& original);
 
    Variant_Base(Variant_Base&& original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(Variant_ConstructFromStdTag, size_t index);
#endif
 
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06);
 
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 Variant&&            original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type allocator,
                 Variant_ConstructFromStdTag,
                 size_t         index);
#endif
 
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06);
 
#else
 
    Variant_Base();
 
    Variant_Base(const Variant& original);
 
    Variant_Base(BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type                          allocator,
                 BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
#endif
 
    ~Variant_Base();
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06>
    void baseEmplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06));
#else
    template <size_t t_INDEX>
    void baseEmplace();
    template <size_t t_INDEX, class t_ARG_01>
    void baseEmplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    void baseEmplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
#endif
 
    Variant_Base& operator=(const Variant_Base& rhs);
 
    Variant_Base& operator=(BloombergLP::bslmf::MovableRef<Variant_Base> rhs);
 
    void reset() BSLS_KEYWORD_NOEXCEPT;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
struct Variant_Base<t_HEAD, t_TAIL_01,
                            t_TAIL_02,
                            t_TAIL_03,
                            t_TAIL_04,
                            t_TAIL_05,
                            t_TAIL_06,
                            t_TAIL_07>
: public BloombergLP::bslstl::Variant_AllocatorBase<
      BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                         t_TAIL_01,
                                                         t_TAIL_02,
                                                         t_TAIL_03,
                                                         t_TAIL_04,
                                                         t_TAIL_05,
                                                         t_TAIL_06,
                                                         t_TAIL_07>::value> {
 
    typedef BloombergLP::bslmf::MovableRefUtil MoveUtil;
    typedef BloombergLP::bslstl::Variant_AllocatorBase<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07>::value>
        AllocBase;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07>
                                            Variant_Union;
    typedef bsl::variant<t_HEAD, t_TAIL_01,
                                 t_TAIL_02,
                                 t_TAIL_03,
                                 t_TAIL_04,
                                 t_TAIL_05,
                                 t_TAIL_06,
                                 t_TAIL_07> Variant;
 
    struct NoAlloc {
    };
 
    typedef typename bsl::conditional<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07>::value,
        bsl::allocator<char>,
        NoAlloc>::type allocator_type;
 
 
    size_t        d_type;
 
    Variant_Union d_union;
 
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07>::value));
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    Variant_Base();
 
    Variant_Base(const Variant_Base& original);
 
    Variant_Base(Variant_Base&& original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(Variant_ConstructFromStdTag, size_t index);
#endif
 
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06,
                              class t_ARGS_07>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07);
 
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 Variant&&            original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type allocator,
                 Variant_ConstructFromStdTag,
                 size_t         index);
#endif
 
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06,
                              class t_ARGS_07>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07);
 
#else
 
    Variant_Base();
 
    Variant_Base(const Variant& original);
 
    Variant_Base(BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type                          allocator,
                 BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
#endif
 
    ~Variant_Base();
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06,
                              class t_ARGS_07>
    void baseEmplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07));
#else
    template <size_t t_INDEX>
    void baseEmplace();
    template <size_t t_INDEX, class t_ARG_01>
    void baseEmplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    void baseEmplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
#endif
 
    Variant_Base& operator=(const Variant_Base& rhs);
 
    Variant_Base& operator=(BloombergLP::bslmf::MovableRef<Variant_Base> rhs);
 
    void reset() BSLS_KEYWORD_NOEXCEPT;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
struct Variant_Base<t_HEAD, t_TAIL_01,
                            t_TAIL_02,
                            t_TAIL_03,
                            t_TAIL_04,
                            t_TAIL_05,
                            t_TAIL_06,
                            t_TAIL_07,
                            t_TAIL_08>
: public BloombergLP::bslstl::Variant_AllocatorBase<
      BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                         t_TAIL_01,
                                                         t_TAIL_02,
                                                         t_TAIL_03,
                                                         t_TAIL_04,
                                                         t_TAIL_05,
                                                         t_TAIL_06,
                                                         t_TAIL_07,
                                                         t_TAIL_08>::value> {
 
    typedef BloombergLP::bslmf::MovableRefUtil MoveUtil;
    typedef BloombergLP::bslstl::Variant_AllocatorBase<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08>::value>
        AllocBase;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08>
                                            Variant_Union;
    typedef bsl::variant<t_HEAD, t_TAIL_01,
                                 t_TAIL_02,
                                 t_TAIL_03,
                                 t_TAIL_04,
                                 t_TAIL_05,
                                 t_TAIL_06,
                                 t_TAIL_07,
                                 t_TAIL_08> Variant;
 
    struct NoAlloc {
    };
 
    typedef typename bsl::conditional<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08>::value,
        bsl::allocator<char>,
        NoAlloc>::type allocator_type;
 
 
    size_t        d_type;
 
    Variant_Union d_union;
 
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08>::value));
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    Variant_Base();
 
    Variant_Base(const Variant_Base& original);
 
    Variant_Base(Variant_Base&& original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(Variant_ConstructFromStdTag, size_t index);
#endif
 
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06,
                              class t_ARGS_07,
                              class t_ARGS_08>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08);
 
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 Variant&&            original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type allocator,
                 Variant_ConstructFromStdTag,
                 size_t         index);
#endif
 
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06,
                              class t_ARGS_07,
                              class t_ARGS_08>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08);
 
#else
 
    Variant_Base();
 
    Variant_Base(const Variant& original);
 
    Variant_Base(BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type                          allocator,
                 BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
#endif
 
    ~Variant_Base();
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06,
                              class t_ARGS_07,
                              class t_ARGS_08>
    void baseEmplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08));
#else
    template <size_t t_INDEX>
    void baseEmplace();
    template <size_t t_INDEX, class t_ARG_01>
    void baseEmplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    void baseEmplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
#endif
 
    Variant_Base& operator=(const Variant_Base& rhs);
 
    Variant_Base& operator=(BloombergLP::bslmf::MovableRef<Variant_Base> rhs);
 
    void reset() BSLS_KEYWORD_NOEXCEPT;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
struct Variant_Base<t_HEAD, t_TAIL_01,
                            t_TAIL_02,
                            t_TAIL_03,
                            t_TAIL_04,
                            t_TAIL_05,
                            t_TAIL_06,
                            t_TAIL_07,
                            t_TAIL_08,
                            t_TAIL_09>
: public BloombergLP::bslstl::Variant_AllocatorBase<
      BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                         t_TAIL_01,
                                                         t_TAIL_02,
                                                         t_TAIL_03,
                                                         t_TAIL_04,
                                                         t_TAIL_05,
                                                         t_TAIL_06,
                                                         t_TAIL_07,
                                                         t_TAIL_08,
                                                         t_TAIL_09>::value> {
 
    typedef BloombergLP::bslmf::MovableRefUtil MoveUtil;
    typedef BloombergLP::bslstl::Variant_AllocatorBase<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09>::value>
        AllocBase;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09>
                                            Variant_Union;
    typedef bsl::variant<t_HEAD, t_TAIL_01,
                                 t_TAIL_02,
                                 t_TAIL_03,
                                 t_TAIL_04,
                                 t_TAIL_05,
                                 t_TAIL_06,
                                 t_TAIL_07,
                                 t_TAIL_08,
                                 t_TAIL_09> Variant;
 
    struct NoAlloc {
    };
 
    typedef typename bsl::conditional<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09>::value,
        bsl::allocator<char>,
        NoAlloc>::type allocator_type;
 
 
    size_t        d_type;
 
    Variant_Union d_union;
 
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09>::value));
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    Variant_Base();
 
    Variant_Base(const Variant_Base& original);
 
    Variant_Base(Variant_Base&& original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(Variant_ConstructFromStdTag, size_t index);
#endif
 
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06,
                              class t_ARGS_07,
                              class t_ARGS_08,
                              class t_ARGS_09>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09);
 
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 Variant&&            original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type allocator,
                 Variant_ConstructFromStdTag,
                 size_t         index);
#endif
 
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06,
                              class t_ARGS_07,
                              class t_ARGS_08,
                              class t_ARGS_09>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09);
 
#else
 
    Variant_Base();
 
    Variant_Base(const Variant& original);
 
    Variant_Base(BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type                          allocator,
                 BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
#endif
 
    ~Variant_Base();
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06,
                              class t_ARGS_07,
                              class t_ARGS_08,
                              class t_ARGS_09>
    void baseEmplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09));
#else
    template <size_t t_INDEX>
    void baseEmplace();
    template <size_t t_INDEX, class t_ARG_01>
    void baseEmplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    void baseEmplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
#endif
 
    Variant_Base& operator=(const Variant_Base& rhs);
 
    Variant_Base& operator=(BloombergLP::bslmf::MovableRef<Variant_Base> rhs);
 
    void reset() BSLS_KEYWORD_NOEXCEPT;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
struct Variant_Base<t_HEAD, t_TAIL_01,
                            t_TAIL_02,
                            t_TAIL_03,
                            t_TAIL_04,
                            t_TAIL_05,
                            t_TAIL_06,
                            t_TAIL_07,
                            t_TAIL_08,
                            t_TAIL_09,
                            t_TAIL_10>
: public BloombergLP::bslstl::Variant_AllocatorBase<
      BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                         t_TAIL_01,
                                                         t_TAIL_02,
                                                         t_TAIL_03,
                                                         t_TAIL_04,
                                                         t_TAIL_05,
                                                         t_TAIL_06,
                                                         t_TAIL_07,
                                                         t_TAIL_08,
                                                         t_TAIL_09,
                                                         t_TAIL_10>::value> {
 
    typedef BloombergLP::bslmf::MovableRefUtil MoveUtil;
    typedef BloombergLP::bslstl::Variant_AllocatorBase<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10>::value>
        AllocBase;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10>
                                            Variant_Union;
    typedef bsl::variant<t_HEAD, t_TAIL_01,
                                 t_TAIL_02,
                                 t_TAIL_03,
                                 t_TAIL_04,
                                 t_TAIL_05,
                                 t_TAIL_06,
                                 t_TAIL_07,
                                 t_TAIL_08,
                                 t_TAIL_09,
                                 t_TAIL_10> Variant;
 
    struct NoAlloc {
    };
 
    typedef typename bsl::conditional<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10>::value,
        bsl::allocator<char>,
        NoAlloc>::type allocator_type;
 
 
    size_t        d_type;
 
    Variant_Union d_union;
 
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10>::value));
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    Variant_Base();
 
    Variant_Base(const Variant_Base& original);
 
    Variant_Base(Variant_Base&& original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(Variant_ConstructFromStdTag, size_t index);
#endif
 
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06,
                              class t_ARGS_07,
                              class t_ARGS_08,
                              class t_ARGS_09,
                              class t_ARGS_10>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10);
 
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 Variant&&            original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type allocator,
                 Variant_ConstructFromStdTag,
                 size_t         index);
#endif
 
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06,
                              class t_ARGS_07,
                              class t_ARGS_08,
                              class t_ARGS_09,
                              class t_ARGS_10>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10);
 
#else
 
    Variant_Base();
 
    Variant_Base(const Variant& original);
 
    Variant_Base(BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type                          allocator,
                 BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
#endif
 
    ~Variant_Base();
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06,
                              class t_ARGS_07,
                              class t_ARGS_08,
                              class t_ARGS_09,
                              class t_ARGS_10>
    void baseEmplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10));
#else
    template <size_t t_INDEX>
    void baseEmplace();
    template <size_t t_INDEX, class t_ARG_01>
    void baseEmplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    void baseEmplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
#endif
 
    Variant_Base& operator=(const Variant_Base& rhs);
 
    Variant_Base& operator=(BloombergLP::bslmf::MovableRef<Variant_Base> rhs);
 
    void reset() BSLS_KEYWORD_NOEXCEPT;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
struct Variant_Base<t_HEAD, t_TAIL_01,
                            t_TAIL_02,
                            t_TAIL_03,
                            t_TAIL_04,
                            t_TAIL_05,
                            t_TAIL_06,
                            t_TAIL_07,
                            t_TAIL_08,
                            t_TAIL_09,
                            t_TAIL_10,
                            t_TAIL_11>
: public BloombergLP::bslstl::Variant_AllocatorBase<
      BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                         t_TAIL_01,
                                                         t_TAIL_02,
                                                         t_TAIL_03,
                                                         t_TAIL_04,
                                                         t_TAIL_05,
                                                         t_TAIL_06,
                                                         t_TAIL_07,
                                                         t_TAIL_08,
                                                         t_TAIL_09,
                                                         t_TAIL_10,
                                                         t_TAIL_11>::value> {
 
    typedef BloombergLP::bslmf::MovableRefUtil MoveUtil;
    typedef BloombergLP::bslstl::Variant_AllocatorBase<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11>::value>
        AllocBase;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11>
                                            Variant_Union;
    typedef bsl::variant<t_HEAD, t_TAIL_01,
                                 t_TAIL_02,
                                 t_TAIL_03,
                                 t_TAIL_04,
                                 t_TAIL_05,
                                 t_TAIL_06,
                                 t_TAIL_07,
                                 t_TAIL_08,
                                 t_TAIL_09,
                                 t_TAIL_10,
                                 t_TAIL_11> Variant;
 
    struct NoAlloc {
    };
 
    typedef typename bsl::conditional<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11>::value,
        bsl::allocator<char>,
        NoAlloc>::type allocator_type;
 
 
    size_t        d_type;
 
    Variant_Union d_union;
 
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11>::value));
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    Variant_Base();
 
    Variant_Base(const Variant_Base& original);
 
    Variant_Base(Variant_Base&& original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(Variant_ConstructFromStdTag, size_t index);
#endif
 
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06,
                              class t_ARGS_07,
                              class t_ARGS_08,
                              class t_ARGS_09,
                              class t_ARGS_10,
                              class t_ARGS_11>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11);
 
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 Variant&&            original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type allocator,
                 Variant_ConstructFromStdTag,
                 size_t         index);
#endif
 
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06,
                              class t_ARGS_07,
                              class t_ARGS_08,
                              class t_ARGS_09,
                              class t_ARGS_10,
                              class t_ARGS_11>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11);
 
#else
 
    Variant_Base();
 
    Variant_Base(const Variant& original);
 
    Variant_Base(BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type                          allocator,
                 BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
#endif
 
    ~Variant_Base();
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06,
                              class t_ARGS_07,
                              class t_ARGS_08,
                              class t_ARGS_09,
                              class t_ARGS_10,
                              class t_ARGS_11>
    void baseEmplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11));
#else
    template <size_t t_INDEX>
    void baseEmplace();
    template <size_t t_INDEX, class t_ARG_01>
    void baseEmplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    void baseEmplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
#endif
 
    Variant_Base& operator=(const Variant_Base& rhs);
 
    Variant_Base& operator=(BloombergLP::bslmf::MovableRef<Variant_Base> rhs);
 
    void reset() BSLS_KEYWORD_NOEXCEPT;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
struct Variant_Base<t_HEAD, t_TAIL_01,
                            t_TAIL_02,
                            t_TAIL_03,
                            t_TAIL_04,
                            t_TAIL_05,
                            t_TAIL_06,
                            t_TAIL_07,
                            t_TAIL_08,
                            t_TAIL_09,
                            t_TAIL_10,
                            t_TAIL_11,
                            t_TAIL_12>
: public BloombergLP::bslstl::Variant_AllocatorBase<
      BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                         t_TAIL_01,
                                                         t_TAIL_02,
                                                         t_TAIL_03,
                                                         t_TAIL_04,
                                                         t_TAIL_05,
                                                         t_TAIL_06,
                                                         t_TAIL_07,
                                                         t_TAIL_08,
                                                         t_TAIL_09,
                                                         t_TAIL_10,
                                                         t_TAIL_11,
                                                         t_TAIL_12>::value> {
 
    typedef BloombergLP::bslmf::MovableRefUtil MoveUtil;
    typedef BloombergLP::bslstl::Variant_AllocatorBase<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12>::value>
        AllocBase;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11,
                                                       t_TAIL_12>
                                            Variant_Union;
    typedef bsl::variant<t_HEAD, t_TAIL_01,
                                 t_TAIL_02,
                                 t_TAIL_03,
                                 t_TAIL_04,
                                 t_TAIL_05,
                                 t_TAIL_06,
                                 t_TAIL_07,
                                 t_TAIL_08,
                                 t_TAIL_09,
                                 t_TAIL_10,
                                 t_TAIL_11,
                                 t_TAIL_12> Variant;
 
    struct NoAlloc {
    };
 
    typedef typename bsl::conditional<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12>::value,
        bsl::allocator<char>,
        NoAlloc>::type allocator_type;
 
 
    size_t        d_type;
 
    Variant_Union d_union;
 
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11,
                                                   t_TAIL_12>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11,
                                                   t_TAIL_12>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12>::value));
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    Variant_Base();
 
    Variant_Base(const Variant_Base& original);
 
    Variant_Base(Variant_Base&& original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(Variant_ConstructFromStdTag, size_t index);
#endif
 
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06,
                              class t_ARGS_07,
                              class t_ARGS_08,
                              class t_ARGS_09,
                              class t_ARGS_10,
                              class t_ARGS_11,
                              class t_ARGS_12>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12);
 
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 Variant&&            original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type allocator,
                 Variant_ConstructFromStdTag,
                 size_t         index);
#endif
 
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06,
                              class t_ARGS_07,
                              class t_ARGS_08,
                              class t_ARGS_09,
                              class t_ARGS_10,
                              class t_ARGS_11,
                              class t_ARGS_12>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12);
 
#else
 
    Variant_Base();
 
    Variant_Base(const Variant& original);
 
    Variant_Base(BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type                          allocator,
                 BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
#endif
 
    ~Variant_Base();
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06,
                              class t_ARGS_07,
                              class t_ARGS_08,
                              class t_ARGS_09,
                              class t_ARGS_10,
                              class t_ARGS_11,
                              class t_ARGS_12>
    void baseEmplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12));
#else
    template <size_t t_INDEX>
    void baseEmplace();
    template <size_t t_INDEX, class t_ARG_01>
    void baseEmplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    void baseEmplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
#endif
 
    Variant_Base& operator=(const Variant_Base& rhs);
 
    Variant_Base& operator=(BloombergLP::bslmf::MovableRef<Variant_Base> rhs);
 
    void reset() BSLS_KEYWORD_NOEXCEPT;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
struct Variant_Base<t_HEAD, t_TAIL_01,
                            t_TAIL_02,
                            t_TAIL_03,
                            t_TAIL_04,
                            t_TAIL_05,
                            t_TAIL_06,
                            t_TAIL_07,
                            t_TAIL_08,
                            t_TAIL_09,
                            t_TAIL_10,
                            t_TAIL_11,
                            t_TAIL_12,
                            t_TAIL_13>
: public BloombergLP::bslstl::Variant_AllocatorBase<
      BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                         t_TAIL_01,
                                                         t_TAIL_02,
                                                         t_TAIL_03,
                                                         t_TAIL_04,
                                                         t_TAIL_05,
                                                         t_TAIL_06,
                                                         t_TAIL_07,
                                                         t_TAIL_08,
                                                         t_TAIL_09,
                                                         t_TAIL_10,
                                                         t_TAIL_11,
                                                         t_TAIL_12,
                                                         t_TAIL_13>::value> {
 
    typedef BloombergLP::bslmf::MovableRefUtil MoveUtil;
    typedef BloombergLP::bslstl::Variant_AllocatorBase<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13>::value>
        AllocBase;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11,
                                                       t_TAIL_12,
                                                       t_TAIL_13>
                                            Variant_Union;
    typedef bsl::variant<t_HEAD, t_TAIL_01,
                                 t_TAIL_02,
                                 t_TAIL_03,
                                 t_TAIL_04,
                                 t_TAIL_05,
                                 t_TAIL_06,
                                 t_TAIL_07,
                                 t_TAIL_08,
                                 t_TAIL_09,
                                 t_TAIL_10,
                                 t_TAIL_11,
                                 t_TAIL_12,
                                 t_TAIL_13> Variant;
 
    struct NoAlloc {
    };
 
    typedef typename bsl::conditional<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13>::value,
        bsl::allocator<char>,
        NoAlloc>::type allocator_type;
 
 
    size_t        d_type;
 
    Variant_Union d_union;
 
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11,
                                                   t_TAIL_12,
                                                   t_TAIL_13>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11,
                                                   t_TAIL_12,
                                                   t_TAIL_13>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13>::value));
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    Variant_Base();
 
    Variant_Base(const Variant_Base& original);
 
    Variant_Base(Variant_Base&& original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(Variant_ConstructFromStdTag, size_t index);
#endif
 
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06,
                              class t_ARGS_07,
                              class t_ARGS_08,
                              class t_ARGS_09,
                              class t_ARGS_10,
                              class t_ARGS_11,
                              class t_ARGS_12,
                              class t_ARGS_13>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13);
 
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 Variant&&            original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type allocator,
                 Variant_ConstructFromStdTag,
                 size_t         index);
#endif
 
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06,
                              class t_ARGS_07,
                              class t_ARGS_08,
                              class t_ARGS_09,
                              class t_ARGS_10,
                              class t_ARGS_11,
                              class t_ARGS_12,
                              class t_ARGS_13>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13);
 
#else
 
    Variant_Base();
 
    Variant_Base(const Variant& original);
 
    Variant_Base(BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type                          allocator,
                 BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
#endif
 
    ~Variant_Base();
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06,
                              class t_ARGS_07,
                              class t_ARGS_08,
                              class t_ARGS_09,
                              class t_ARGS_10,
                              class t_ARGS_11,
                              class t_ARGS_12,
                              class t_ARGS_13>
    void baseEmplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13));
#else
    template <size_t t_INDEX>
    void baseEmplace();
    template <size_t t_INDEX, class t_ARG_01>
    void baseEmplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    void baseEmplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
#endif
 
    Variant_Base& operator=(const Variant_Base& rhs);
 
    Variant_Base& operator=(BloombergLP::bslmf::MovableRef<Variant_Base> rhs);
 
    void reset() BSLS_KEYWORD_NOEXCEPT;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
struct Variant_Base<t_HEAD, t_TAIL_01,
                            t_TAIL_02,
                            t_TAIL_03,
                            t_TAIL_04,
                            t_TAIL_05,
                            t_TAIL_06,
                            t_TAIL_07,
                            t_TAIL_08,
                            t_TAIL_09,
                            t_TAIL_10,
                            t_TAIL_11,
                            t_TAIL_12,
                            t_TAIL_13,
                            t_TAIL_14>
: public BloombergLP::bslstl::Variant_AllocatorBase<
      BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                         t_TAIL_01,
                                                         t_TAIL_02,
                                                         t_TAIL_03,
                                                         t_TAIL_04,
                                                         t_TAIL_05,
                                                         t_TAIL_06,
                                                         t_TAIL_07,
                                                         t_TAIL_08,
                                                         t_TAIL_09,
                                                         t_TAIL_10,
                                                         t_TAIL_11,
                                                         t_TAIL_12,
                                                         t_TAIL_13,
                                                         t_TAIL_14>::value> {
 
    typedef BloombergLP::bslmf::MovableRefUtil MoveUtil;
    typedef BloombergLP::bslstl::Variant_AllocatorBase<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14>::value>
        AllocBase;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11,
                                                       t_TAIL_12,
                                                       t_TAIL_13,
                                                       t_TAIL_14>
                                            Variant_Union;
    typedef bsl::variant<t_HEAD, t_TAIL_01,
                                 t_TAIL_02,
                                 t_TAIL_03,
                                 t_TAIL_04,
                                 t_TAIL_05,
                                 t_TAIL_06,
                                 t_TAIL_07,
                                 t_TAIL_08,
                                 t_TAIL_09,
                                 t_TAIL_10,
                                 t_TAIL_11,
                                 t_TAIL_12,
                                 t_TAIL_13,
                                 t_TAIL_14> Variant;
 
    struct NoAlloc {
    };
 
    typedef typename bsl::conditional<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14>::value,
        bsl::allocator<char>,
        NoAlloc>::type allocator_type;
 
 
    size_t        d_type;
 
    Variant_Union d_union;
 
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11,
                                                   t_TAIL_12,
                                                   t_TAIL_13,
                                                   t_TAIL_14>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11,
                                                   t_TAIL_12,
                                                   t_TAIL_13,
                                                   t_TAIL_14>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14>::value));
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    Variant_Base();
 
    Variant_Base(const Variant_Base& original);
 
    Variant_Base(Variant_Base&& original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(Variant_ConstructFromStdTag, size_t index);
#endif
 
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06,
                              class t_ARGS_07,
                              class t_ARGS_08,
                              class t_ARGS_09,
                              class t_ARGS_10,
                              class t_ARGS_11,
                              class t_ARGS_12,
                              class t_ARGS_13,
                              class t_ARGS_14>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14);
 
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 Variant&&            original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type allocator,
                 Variant_ConstructFromStdTag,
                 size_t         index);
#endif
 
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06,
                              class t_ARGS_07,
                              class t_ARGS_08,
                              class t_ARGS_09,
                              class t_ARGS_10,
                              class t_ARGS_11,
                              class t_ARGS_12,
                              class t_ARGS_13,
                              class t_ARGS_14>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14);
 
#else
 
    Variant_Base();
 
    Variant_Base(const Variant& original);
 
    Variant_Base(BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type                          allocator,
                 BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
#endif
 
    ~Variant_Base();
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06,
                              class t_ARGS_07,
                              class t_ARGS_08,
                              class t_ARGS_09,
                              class t_ARGS_10,
                              class t_ARGS_11,
                              class t_ARGS_12,
                              class t_ARGS_13,
                              class t_ARGS_14>
    void baseEmplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14));
#else
    template <size_t t_INDEX>
    void baseEmplace();
    template <size_t t_INDEX, class t_ARG_01>
    void baseEmplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    void baseEmplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
#endif
 
    Variant_Base& operator=(const Variant_Base& rhs);
 
    Variant_Base& operator=(BloombergLP::bslmf::MovableRef<Variant_Base> rhs);
 
    void reset() BSLS_KEYWORD_NOEXCEPT;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
struct Variant_Base<t_HEAD, t_TAIL_01,
                            t_TAIL_02,
                            t_TAIL_03,
                            t_TAIL_04,
                            t_TAIL_05,
                            t_TAIL_06,
                            t_TAIL_07,
                            t_TAIL_08,
                            t_TAIL_09,
                            t_TAIL_10,
                            t_TAIL_11,
                            t_TAIL_12,
                            t_TAIL_13,
                            t_TAIL_14,
                            t_TAIL_15>
: public BloombergLP::bslstl::Variant_AllocatorBase<
      BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                         t_TAIL_01,
                                                         t_TAIL_02,
                                                         t_TAIL_03,
                                                         t_TAIL_04,
                                                         t_TAIL_05,
                                                         t_TAIL_06,
                                                         t_TAIL_07,
                                                         t_TAIL_08,
                                                         t_TAIL_09,
                                                         t_TAIL_10,
                                                         t_TAIL_11,
                                                         t_TAIL_12,
                                                         t_TAIL_13,
                                                         t_TAIL_14,
                                                         t_TAIL_15>::value> {
 
    typedef BloombergLP::bslmf::MovableRefUtil MoveUtil;
    typedef BloombergLP::bslstl::Variant_AllocatorBase<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14,
                                                           t_TAIL_15>::value>
        AllocBase;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11,
                                                       t_TAIL_12,
                                                       t_TAIL_13,
                                                       t_TAIL_14,
                                                       t_TAIL_15>
                                            Variant_Union;
    typedef bsl::variant<t_HEAD, t_TAIL_01,
                                 t_TAIL_02,
                                 t_TAIL_03,
                                 t_TAIL_04,
                                 t_TAIL_05,
                                 t_TAIL_06,
                                 t_TAIL_07,
                                 t_TAIL_08,
                                 t_TAIL_09,
                                 t_TAIL_10,
                                 t_TAIL_11,
                                 t_TAIL_12,
                                 t_TAIL_13,
                                 t_TAIL_14,
                                 t_TAIL_15> Variant;
 
    struct NoAlloc {
    };
 
    typedef typename bsl::conditional<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14,
                                                           t_TAIL_15>::value,
        bsl::allocator<char>,
        NoAlloc>::type allocator_type;
 
 
    size_t        d_type;
 
    Variant_Union d_union;
 
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11,
                                                   t_TAIL_12,
                                                   t_TAIL_13,
                                                   t_TAIL_14,
                                                   t_TAIL_15>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11,
                                                   t_TAIL_12,
                                                   t_TAIL_13,
                                                   t_TAIL_14,
                                                   t_TAIL_15>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14,
                                                           t_TAIL_15>::value));
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    Variant_Base();
 
    Variant_Base(const Variant_Base& original);
 
    Variant_Base(Variant_Base&& original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(Variant_ConstructFromStdTag, size_t index);
#endif
 
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06,
                              class t_ARGS_07,
                              class t_ARGS_08,
                              class t_ARGS_09,
                              class t_ARGS_10,
                              class t_ARGS_11,
                              class t_ARGS_12,
                              class t_ARGS_13,
                              class t_ARGS_14,
                              class t_ARGS_15>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15);
 
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 Variant&&            original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type allocator,
                 Variant_ConstructFromStdTag,
                 size_t         index);
#endif
 
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06,
                              class t_ARGS_07,
                              class t_ARGS_08,
                              class t_ARGS_09,
                              class t_ARGS_10,
                              class t_ARGS_11,
                              class t_ARGS_12,
                              class t_ARGS_13,
                              class t_ARGS_14,
                              class t_ARGS_15>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15);
 
#else
 
    Variant_Base();
 
    Variant_Base(const Variant& original);
 
    Variant_Base(BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type                          allocator,
                 BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
#endif
 
    ~Variant_Base();
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06,
                              class t_ARGS_07,
                              class t_ARGS_08,
                              class t_ARGS_09,
                              class t_ARGS_10,
                              class t_ARGS_11,
                              class t_ARGS_12,
                              class t_ARGS_13,
                              class t_ARGS_14,
                              class t_ARGS_15>
    void baseEmplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15));
#else
    template <size_t t_INDEX>
    void baseEmplace();
    template <size_t t_INDEX, class t_ARG_01>
    void baseEmplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    void baseEmplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
#endif
 
    Variant_Base& operator=(const Variant_Base& rhs);
 
    Variant_Base& operator=(BloombergLP::bslmf::MovableRef<Variant_Base> rhs);
 
    void reset() BSLS_KEYWORD_NOEXCEPT;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
struct Variant_Base<t_HEAD, t_TAIL_01,
                            t_TAIL_02,
                            t_TAIL_03,
                            t_TAIL_04,
                            t_TAIL_05,
                            t_TAIL_06,
                            t_TAIL_07,
                            t_TAIL_08,
                            t_TAIL_09,
                            t_TAIL_10,
                            t_TAIL_11,
                            t_TAIL_12,
                            t_TAIL_13,
                            t_TAIL_14,
                            t_TAIL_15,
                            t_TAIL_16>
: public BloombergLP::bslstl::Variant_AllocatorBase<
      BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                         t_TAIL_01,
                                                         t_TAIL_02,
                                                         t_TAIL_03,
                                                         t_TAIL_04,
                                                         t_TAIL_05,
                                                         t_TAIL_06,
                                                         t_TAIL_07,
                                                         t_TAIL_08,
                                                         t_TAIL_09,
                                                         t_TAIL_10,
                                                         t_TAIL_11,
                                                         t_TAIL_12,
                                                         t_TAIL_13,
                                                         t_TAIL_14,
                                                         t_TAIL_15,
                                                         t_TAIL_16>::value> {
 
    typedef BloombergLP::bslmf::MovableRefUtil MoveUtil;
    typedef BloombergLP::bslstl::Variant_AllocatorBase<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14,
                                                           t_TAIL_15,
                                                           t_TAIL_16>::value>
        AllocBase;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11,
                                                       t_TAIL_12,
                                                       t_TAIL_13,
                                                       t_TAIL_14,
                                                       t_TAIL_15,
                                                       t_TAIL_16>
                                            Variant_Union;
    typedef bsl::variant<t_HEAD, t_TAIL_01,
                                 t_TAIL_02,
                                 t_TAIL_03,
                                 t_TAIL_04,
                                 t_TAIL_05,
                                 t_TAIL_06,
                                 t_TAIL_07,
                                 t_TAIL_08,
                                 t_TAIL_09,
                                 t_TAIL_10,
                                 t_TAIL_11,
                                 t_TAIL_12,
                                 t_TAIL_13,
                                 t_TAIL_14,
                                 t_TAIL_15,
                                 t_TAIL_16> Variant;
 
    struct NoAlloc {
    };
 
    typedef typename bsl::conditional<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14,
                                                           t_TAIL_15,
                                                           t_TAIL_16>::value,
        bsl::allocator<char>,
        NoAlloc>::type allocator_type;
 
 
    size_t        d_type;
 
    Variant_Union d_union;
 
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11,
                                                   t_TAIL_12,
                                                   t_TAIL_13,
                                                   t_TAIL_14,
                                                   t_TAIL_15,
                                                   t_TAIL_16>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11,
                                                   t_TAIL_12,
                                                   t_TAIL_13,
                                                   t_TAIL_14,
                                                   t_TAIL_15,
                                                   t_TAIL_16>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14,
                                                           t_TAIL_15,
                                                           t_TAIL_16>::value));
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    Variant_Base();
 
    Variant_Base(const Variant_Base& original);
 
    Variant_Base(Variant_Base&& original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(Variant_ConstructFromStdTag, size_t index);
#endif
 
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06,
                              class t_ARGS_07,
                              class t_ARGS_08,
                              class t_ARGS_09,
                              class t_ARGS_10,
                              class t_ARGS_11,
                              class t_ARGS_12,
                              class t_ARGS_13,
                              class t_ARGS_14,
                              class t_ARGS_15,
                              class t_ARGS_16>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16);
 
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 Variant&&            original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type allocator,
                 Variant_ConstructFromStdTag,
                 size_t         index);
#endif
 
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06,
                              class t_ARGS_07,
                              class t_ARGS_08,
                              class t_ARGS_09,
                              class t_ARGS_10,
                              class t_ARGS_11,
                              class t_ARGS_12,
                              class t_ARGS_13,
                              class t_ARGS_14,
                              class t_ARGS_15,
                              class t_ARGS_16>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16);
 
#else
 
    Variant_Base();
 
    Variant_Base(const Variant& original);
 
    Variant_Base(BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type                          allocator,
                 BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
#endif
 
    ~Variant_Base();
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06,
                              class t_ARGS_07,
                              class t_ARGS_08,
                              class t_ARGS_09,
                              class t_ARGS_10,
                              class t_ARGS_11,
                              class t_ARGS_12,
                              class t_ARGS_13,
                              class t_ARGS_14,
                              class t_ARGS_15,
                              class t_ARGS_16>
    void baseEmplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16));
#else
    template <size_t t_INDEX>
    void baseEmplace();
    template <size_t t_INDEX, class t_ARG_01>
    void baseEmplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    void baseEmplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
#endif
 
    Variant_Base& operator=(const Variant_Base& rhs);
 
    Variant_Base& operator=(BloombergLP::bslmf::MovableRef<Variant_Base> rhs);
 
    void reset() BSLS_KEYWORD_NOEXCEPT;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
struct Variant_Base<t_HEAD, t_TAIL_01,
                            t_TAIL_02,
                            t_TAIL_03,
                            t_TAIL_04,
                            t_TAIL_05,
                            t_TAIL_06,
                            t_TAIL_07,
                            t_TAIL_08,
                            t_TAIL_09,
                            t_TAIL_10,
                            t_TAIL_11,
                            t_TAIL_12,
                            t_TAIL_13,
                            t_TAIL_14,
                            t_TAIL_15,
                            t_TAIL_16,
                            t_TAIL_17>
: public BloombergLP::bslstl::Variant_AllocatorBase<
      BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                         t_TAIL_01,
                                                         t_TAIL_02,
                                                         t_TAIL_03,
                                                         t_TAIL_04,
                                                         t_TAIL_05,
                                                         t_TAIL_06,
                                                         t_TAIL_07,
                                                         t_TAIL_08,
                                                         t_TAIL_09,
                                                         t_TAIL_10,
                                                         t_TAIL_11,
                                                         t_TAIL_12,
                                                         t_TAIL_13,
                                                         t_TAIL_14,
                                                         t_TAIL_15,
                                                         t_TAIL_16,
                                                         t_TAIL_17>::value> {
 
    typedef BloombergLP::bslmf::MovableRefUtil MoveUtil;
    typedef BloombergLP::bslstl::Variant_AllocatorBase<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14,
                                                           t_TAIL_15,
                                                           t_TAIL_16,
                                                           t_TAIL_17>::value>
        AllocBase;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11,
                                                       t_TAIL_12,
                                                       t_TAIL_13,
                                                       t_TAIL_14,
                                                       t_TAIL_15,
                                                       t_TAIL_16,
                                                       t_TAIL_17>
                                            Variant_Union;
    typedef bsl::variant<t_HEAD, t_TAIL_01,
                                 t_TAIL_02,
                                 t_TAIL_03,
                                 t_TAIL_04,
                                 t_TAIL_05,
                                 t_TAIL_06,
                                 t_TAIL_07,
                                 t_TAIL_08,
                                 t_TAIL_09,
                                 t_TAIL_10,
                                 t_TAIL_11,
                                 t_TAIL_12,
                                 t_TAIL_13,
                                 t_TAIL_14,
                                 t_TAIL_15,
                                 t_TAIL_16,
                                 t_TAIL_17> Variant;
 
    struct NoAlloc {
    };
 
    typedef typename bsl::conditional<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14,
                                                           t_TAIL_15,
                                                           t_TAIL_16,
                                                           t_TAIL_17>::value,
        bsl::allocator<char>,
        NoAlloc>::type allocator_type;
 
 
    size_t        d_type;
 
    Variant_Union d_union;
 
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11,
                                                   t_TAIL_12,
                                                   t_TAIL_13,
                                                   t_TAIL_14,
                                                   t_TAIL_15,
                                                   t_TAIL_16,
                                                   t_TAIL_17>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11,
                                                   t_TAIL_12,
                                                   t_TAIL_13,
                                                   t_TAIL_14,
                                                   t_TAIL_15,
                                                   t_TAIL_16,
                                                   t_TAIL_17>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14,
                                                           t_TAIL_15,
                                                           t_TAIL_16,
                                                           t_TAIL_17>::value));
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    Variant_Base();
 
    Variant_Base(const Variant_Base& original);
 
    Variant_Base(Variant_Base&& original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(Variant_ConstructFromStdTag, size_t index);
#endif
 
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06,
                              class t_ARGS_07,
                              class t_ARGS_08,
                              class t_ARGS_09,
                              class t_ARGS_10,
                              class t_ARGS_11,
                              class t_ARGS_12,
                              class t_ARGS_13,
                              class t_ARGS_14,
                              class t_ARGS_15,
                              class t_ARGS_16,
                              class t_ARGS_17>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_17) args_17);
 
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 Variant&&            original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type allocator,
                 Variant_ConstructFromStdTag,
                 size_t         index);
#endif
 
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06,
                              class t_ARGS_07,
                              class t_ARGS_08,
                              class t_ARGS_09,
                              class t_ARGS_10,
                              class t_ARGS_11,
                              class t_ARGS_12,
                              class t_ARGS_13,
                              class t_ARGS_14,
                              class t_ARGS_15,
                              class t_ARGS_16,
                              class t_ARGS_17>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_17) args_17);
 
#else
 
    Variant_Base();
 
    Variant_Base(const Variant& original);
 
    Variant_Base(BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type                          allocator,
                 BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
#endif
 
    ~Variant_Base();
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06,
                              class t_ARGS_07,
                              class t_ARGS_08,
                              class t_ARGS_09,
                              class t_ARGS_10,
                              class t_ARGS_11,
                              class t_ARGS_12,
                              class t_ARGS_13,
                              class t_ARGS_14,
                              class t_ARGS_15,
                              class t_ARGS_16,
                              class t_ARGS_17>
    void baseEmplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_17));
#else
    template <size_t t_INDEX>
    void baseEmplace();
    template <size_t t_INDEX, class t_ARG_01>
    void baseEmplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    void baseEmplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
#endif
 
    Variant_Base& operator=(const Variant_Base& rhs);
 
    Variant_Base& operator=(BloombergLP::bslmf::MovableRef<Variant_Base> rhs);
 
    void reset() BSLS_KEYWORD_NOEXCEPT;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
struct Variant_Base<t_HEAD, t_TAIL_01,
                            t_TAIL_02,
                            t_TAIL_03,
                            t_TAIL_04,
                            t_TAIL_05,
                            t_TAIL_06,
                            t_TAIL_07,
                            t_TAIL_08,
                            t_TAIL_09,
                            t_TAIL_10,
                            t_TAIL_11,
                            t_TAIL_12,
                            t_TAIL_13,
                            t_TAIL_14,
                            t_TAIL_15,
                            t_TAIL_16,
                            t_TAIL_17,
                            t_TAIL_18>
: public BloombergLP::bslstl::Variant_AllocatorBase<
      BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                         t_TAIL_01,
                                                         t_TAIL_02,
                                                         t_TAIL_03,
                                                         t_TAIL_04,
                                                         t_TAIL_05,
                                                         t_TAIL_06,
                                                         t_TAIL_07,
                                                         t_TAIL_08,
                                                         t_TAIL_09,
                                                         t_TAIL_10,
                                                         t_TAIL_11,
                                                         t_TAIL_12,
                                                         t_TAIL_13,
                                                         t_TAIL_14,
                                                         t_TAIL_15,
                                                         t_TAIL_16,
                                                         t_TAIL_17,
                                                         t_TAIL_18>::value> {
 
    typedef BloombergLP::bslmf::MovableRefUtil MoveUtil;
    typedef BloombergLP::bslstl::Variant_AllocatorBase<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14,
                                                           t_TAIL_15,
                                                           t_TAIL_16,
                                                           t_TAIL_17,
                                                           t_TAIL_18>::value>
        AllocBase;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11,
                                                       t_TAIL_12,
                                                       t_TAIL_13,
                                                       t_TAIL_14,
                                                       t_TAIL_15,
                                                       t_TAIL_16,
                                                       t_TAIL_17,
                                                       t_TAIL_18>
                                            Variant_Union;
    typedef bsl::variant<t_HEAD, t_TAIL_01,
                                 t_TAIL_02,
                                 t_TAIL_03,
                                 t_TAIL_04,
                                 t_TAIL_05,
                                 t_TAIL_06,
                                 t_TAIL_07,
                                 t_TAIL_08,
                                 t_TAIL_09,
                                 t_TAIL_10,
                                 t_TAIL_11,
                                 t_TAIL_12,
                                 t_TAIL_13,
                                 t_TAIL_14,
                                 t_TAIL_15,
                                 t_TAIL_16,
                                 t_TAIL_17,
                                 t_TAIL_18> Variant;
 
    struct NoAlloc {
    };
 
    typedef typename bsl::conditional<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14,
                                                           t_TAIL_15,
                                                           t_TAIL_16,
                                                           t_TAIL_17,
                                                           t_TAIL_18>::value,
        bsl::allocator<char>,
        NoAlloc>::type allocator_type;
 
 
    size_t        d_type;
 
    Variant_Union d_union;
 
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11,
                                                   t_TAIL_12,
                                                   t_TAIL_13,
                                                   t_TAIL_14,
                                                   t_TAIL_15,
                                                   t_TAIL_16,
                                                   t_TAIL_17,
                                                   t_TAIL_18>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11,
                                                   t_TAIL_12,
                                                   t_TAIL_13,
                                                   t_TAIL_14,
                                                   t_TAIL_15,
                                                   t_TAIL_16,
                                                   t_TAIL_17,
                                                   t_TAIL_18>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14,
                                                           t_TAIL_15,
                                                           t_TAIL_16,
                                                           t_TAIL_17,
                                                           t_TAIL_18>::value));
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    Variant_Base();
 
    Variant_Base(const Variant_Base& original);
 
    Variant_Base(Variant_Base&& original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(Variant_ConstructFromStdTag, size_t index);
#endif
 
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06,
                              class t_ARGS_07,
                              class t_ARGS_08,
                              class t_ARGS_09,
                              class t_ARGS_10,
                              class t_ARGS_11,
                              class t_ARGS_12,
                              class t_ARGS_13,
                              class t_ARGS_14,
                              class t_ARGS_15,
                              class t_ARGS_16,
                              class t_ARGS_17,
                              class t_ARGS_18>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_17) args_17,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_18) args_18);
 
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 Variant&&            original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type allocator,
                 Variant_ConstructFromStdTag,
                 size_t         index);
#endif
 
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06,
                              class t_ARGS_07,
                              class t_ARGS_08,
                              class t_ARGS_09,
                              class t_ARGS_10,
                              class t_ARGS_11,
                              class t_ARGS_12,
                              class t_ARGS_13,
                              class t_ARGS_14,
                              class t_ARGS_15,
                              class t_ARGS_16,
                              class t_ARGS_17,
                              class t_ARGS_18>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_17) args_17,
                         BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_18) args_18);
 
#else
 
    Variant_Base();
 
    Variant_Base(const Variant& original);
 
    Variant_Base(BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type                          allocator,
                 BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
#endif
 
    ~Variant_Base();
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <size_t t_INDEX, class t_ARGS_01,
                              class t_ARGS_02,
                              class t_ARGS_03,
                              class t_ARGS_04,
                              class t_ARGS_05,
                              class t_ARGS_06,
                              class t_ARGS_07,
                              class t_ARGS_08,
                              class t_ARGS_09,
                              class t_ARGS_10,
                              class t_ARGS_11,
                              class t_ARGS_12,
                              class t_ARGS_13,
                              class t_ARGS_14,
                              class t_ARGS_15,
                              class t_ARGS_16,
                              class t_ARGS_17,
                              class t_ARGS_18>
    void baseEmplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_17),
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_18));
#else
    template <size_t t_INDEX>
    void baseEmplace();
    template <size_t t_INDEX, class t_ARG_01>
    void baseEmplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    void baseEmplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
#endif
 
    Variant_Base& operator=(const Variant_Base& rhs);
 
    Variant_Base& operator=(BloombergLP::bslmf::MovableRef<Variant_Base> rhs);
 
    void reset() BSLS_KEYWORD_NOEXCEPT;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 18
 
#else
// The generated code below is a workaround for the absence of perfect
// forwarding in some compilers.
template <class t_HEAD, class... t_TAIL>
struct Variant_Base
: public BloombergLP::bslstl::Variant_AllocatorBase<
      BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                         t_TAIL...>::value> {
 
    typedef BloombergLP::bslmf::MovableRefUtil MoveUtil;
    typedef BloombergLP::bslstl::Variant_AllocatorBase<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                           t_TAIL...>::value>
        AllocBase;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD, t_TAIL...>
                                            Variant_Union;
    typedef bsl::variant<t_HEAD, t_TAIL...> Variant;
 
    struct NoAlloc {
    };
 
    typedef typename bsl::conditional<
        BloombergLP::bslstl::Variant_UsesBslmaAllocatorAny<t_HEAD,
                                                           t_TAIL...>::value,
        bsl::allocator<char>,
        NoAlloc>::type allocator_type;
 
 
    size_t        d_type;
 
    Variant_Union d_union;
 
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL...>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL...>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        Variant_Base,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD,
                                                           t_TAIL...>::value));
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    Variant_Base();
 
    Variant_Base(const Variant_Base& original);
 
    Variant_Base(Variant_Base&& original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(Variant_ConstructFromStdTag, size_t index);
#endif
 
    template <size_t t_INDEX, class... t_ARGS>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>, t_ARGS&&... args);
 
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 Variant&&            original);
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type allocator,
                 Variant_ConstructFromStdTag,
                 size_t         index);
#endif
 
    template <size_t t_INDEX, class... t_ARGS>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          t_ARGS&&...                    args);
 
#else
 
    Variant_Base();
 
    Variant_Base(const Variant& original);
 
    Variant_Base(BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
    Variant_Base(bsl::allocator_arg_t, allocator_type allocator);
 
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type       allocator,
                 const Variant&       original);
    Variant_Base(bsl::allocator_arg_t,
                 allocator_type                          allocator,
                 BloombergLP::bslmf::MovableRef<Variant> original);
 
    template <size_t t_INDEX>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type                 allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01&                arg_01,
                          const t_ARG_02&                arg_02,
                          const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit Variant_Base(bsl::allocator_arg_t,
                          allocator_type allocator,
                          bsl::in_place_index_t<t_INDEX>,
                          const t_ARG_01& arg_01,
                          const t_ARG_02& arg_02,
                          const t_ARG_03& arg_03,
                          const t_ARG_04& arg_04,
                          const t_ARG_05& arg_05,
                          const t_ARG_06& arg_06,
                          const t_ARG_07& arg_07,
                          const t_ARG_08& arg_08,
                          const t_ARG_09& arg_09,
                          const t_ARG_10& arg_10);
 
#endif
 
    ~Variant_Base();
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <size_t t_INDEX, class... t_ARGS>
    void baseEmplace(t_ARGS&&...);
#else
    template <size_t t_INDEX>
    void baseEmplace();
    template <size_t t_INDEX, class t_ARG_01>
    void baseEmplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    void baseEmplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    void baseEmplace(const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
#endif
 
    Variant_Base& operator=(const Variant_Base& rhs);
 
    Variant_Base& operator=(BloombergLP::bslmf::MovableRef<Variant_Base> rhs);
 
    void reset() BSLS_KEYWORD_NOEXCEPT;
};
// }}} END GENERATED CODE
#endif
 
}  // close package namespace
 
 
namespace bsl {
                               // =============
                               // class variant
                               // =============
 
#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
// {{{ BEGIN GENERATED CODE
// Command line: sim_cpp11_features.pl bslstl_variant.h
#ifndef BSLSTL_VARIANT_VARIADIC_LIMIT
#define BSLSTL_VARIANT_VARIADIC_LIMIT 18
#endif
#ifndef BSLSTL_VARIANT_VARIADIC_LIMIT_K
#define BSLSTL_VARIANT_VARIADIC_LIMIT_K BSLSTL_VARIANT_VARIADIC_LIMIT
#endif
#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 0
template <class t_HEAD>
class variant<t_HEAD>
: private BloombergLP::bslstl::Variant_Base<t_HEAD>
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
,
  private BloombergLP::bslstl::Variant_SMFBase<
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD>::value,
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD>::value &&
          BloombergLP::bslstl::Variant_IsCopyAssignableAll<t_HEAD>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD>::value &&
          BloombergLP::bslstl::Variant_IsMoveAssignableAll<t_HEAD>::value>
#endif
{
  private:
    typedef BloombergLP::bslmf::MovableRefUtil                   MoveUtil;
    typedef BloombergLP::bslstl::Variant_Base<t_HEAD> Variant_Base;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD>
        Variant_Union;
 
    friend struct BloombergLP::bslstl::Variant_ImpUtil;
 
    friend struct BloombergLP::bslstl::Variant_Base<t_HEAD>;
 
  public:
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD>::value));
 
 
    typedef typename Variant_Base::allocator_type allocator_type;
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_FIRST_ALT = t_HEAD,
              class             = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST_ALT>::value> >
    variant()
    : Variant_Base()
    {
    }
 
    variant(const variant& original) = default;
 
    variant(variant&& original) = default;
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  BSLS_COMPILERFEATURES_FORWARD_REF(t_STD_VARIANT) original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) t,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&
                                                                    >::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il)
    {
    }
 
    template <size_t   t_INDEX,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  0u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX)
                                                                    >::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>())
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  0u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&
                                                                    >::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   il)
    {
    }
 
    template <class FIRST = t_HEAD,
              class       = typename bsl::enable_if_t<
                  std::is_default_constructible<FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }
 
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<FIRST>::value> >
    variant(bsl::allocator_arg_t,
            allocator_type allocator,
            const variant& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, original)
    {
    }
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator, variant&& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, std::move(original))
    {
    }
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  bsl::allocator_arg_t,
                  allocator_type  allocator,
                  BSLS_COMPILERFEATURES_FORWARD_REF(t_STD_VARIANT) original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(bsl::allocator_arg_t(),
                   allocator,
                   BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) t,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>)
    : Variant_Base(
          bsl::allocator_arg_t{}
,
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&
                                                                    >::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il)
    : Variant_Base(
          bsl::allocator_arg_t{}
,
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il)
    {
    }
 
    template <size_t   t_INDEX,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  0u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX)
                                                                    >::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>)
    : Variant_Base(bsl::allocator_arg_t{}
,
                   allocator,
                   bsl::in_place_index_t<t_INDEX>())
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  0u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&
                                                                    >::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il)
    : Variant_Base(bsl::allocator_arg_t{}
,
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   il)
    {
    }
 
#else
 
    variant();
 
    variant(const variant& original);
 
    variant(BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(const t_TYPE&                                              value,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     const t_ARG_03&                                   arg_03,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::in_place_index_t<t_INDEX>, const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
    variant(bsl::allocator_arg_t, allocator_type allocator);
 
    variant(bsl::allocator_arg_t,
            allocator_type       allocator,
            const variant&       original);
    variant(bsl::allocator_arg_t,
            allocator_type                          allocator,
            BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          const t_TYPE&                                              value,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   const t_ARG_03&                                   arg_03,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
#endif
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_TYPE,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE>::value> >
    t_TYPE& emplace()
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            );
 
        return bsl::get<index>(*this);
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&
                                                                    >::value> >
    t_TYPE& emplace(std::initializer_list<INIT_LIST_TYPE> il)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            il);
 
        return bsl::get<index>(*this);
    }
 
    template <size_t   t_INDEX,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  0u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX)
                                                                    >::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD> >::type&
    emplace()
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            );
 
        return bsl::get<t_INDEX>(*this);
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  0u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&
                                                                    >::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD> >::type&
    emplace(std::initializer_list<INIT_LIST_TYPE> il)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            il);
 
        return bsl::get<t_INDEX>(*this);
    }
 
#else
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace();
 
    template <class t_TYPE, class t_ARG_01>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
 
    template <size_t t_INDEX>
    typename variant_alternative<t_INDEX, variant<t_HEAD> >::type&
    emplace();
 
    template <size_t t_INDEX, class t_ARG_01>
    typename variant_alternative<t_INDEX, variant<t_HEAD> >::type&
    emplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    typename variant_alternative<t_INDEX, variant<t_HEAD> >::type&
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename variant_alternative<t_INDEX, variant<t_HEAD> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename variant_alternative<t_INDEX, variant<t_HEAD> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename variant_alternative<t_INDEX, variant<t_HEAD> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename variant_alternative<t_INDEX, variant<t_HEAD> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename variant_alternative<t_INDEX, variant<t_HEAD> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename variant_alternative<t_INDEX, variant<t_HEAD> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename variant_alternative<t_INDEX, variant<t_HEAD> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename variant_alternative<t_INDEX, variant<t_HEAD> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
#endif
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    variant& operator=(const variant& rhs) = default;
 
    variant& operator=(variant&& rhs) = default;
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) value)
    {
        const size_t altIndex =
            BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
        if (index() == altIndex) {
            bsl::get<altIndex>(*this) = BSLS_COMPILERFEATURES_FORWARD(t_TYPE,
                                        value);
        }
        else {
            Variant_Base::template baseEmplace<altIndex>(
                BSLS_COMPILERFEATURES_FORWARD(t_TYPE, value));
        }
 
        return *this;
    }
#else
    variant& operator=(const variant& rhs);
 
    variant& operator=(BloombergLP::bslmf::MovableRef<variant> rhs);
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(const t_TYPE& value);
 
#endif
 
    void swap(variant& other);
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <bool t_USES_BSLMA_ALLOC = BloombergLP::bslstl::
                  Variant_UsesBslmaAllocatorAny<t_HEAD>::value,
              class = typename bsl::enable_if_t<t_USES_BSLMA_ALLOC> >
#endif
    allocator_type get_allocator() const BSLS_KEYWORD_NOEXCEPT
    {
        return allocator_type(Variant_Base::AllocBase::mechanism());
    }
 
 
    size_t index() const BSLS_KEYWORD_NOEXCEPT;
 
    bool valueless_by_exception() const BSLS_KEYWORD_NOEXCEPT;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 1
template <class t_HEAD, class t_TAIL_01>
class variant<t_HEAD, t_TAIL_01>
: private BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01>
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
,
  private BloombergLP::bslstl::Variant_SMFBase<
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD,
                                                          t_TAIL_01>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD,
                                                          t_TAIL_01>::value,
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD,
                                                          t_TAIL_01>::value &&
          BloombergLP::bslstl::Variant_IsCopyAssignableAll<t_HEAD,
                                                           t_TAIL_01>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD,
                                                          t_TAIL_01>::value &&
          BloombergLP::bslstl::Variant_IsMoveAssignableAll<t_HEAD,
                                                           t_TAIL_01>::value>
#endif
{
  private:
    typedef BloombergLP::bslmf::MovableRefUtil                   MoveUtil;
    typedef BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01> Variant_Base;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD, t_TAIL_01>
        Variant_Union;
 
    friend struct BloombergLP::bslstl::Variant_ImpUtil;
 
    friend struct BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01>;
 
  public:
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD,
                                                           t_TAIL_01>::value));
 
 
    typedef typename Variant_Base::allocator_type allocator_type;
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_FIRST_ALT = t_HEAD,
              class             = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST_ALT>::value> >
    variant()
    : Variant_Base()
    {
    }
 
    variant(const variant& original) = default;
 
    variant(variant&& original) = default;
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  BSLS_COMPILERFEATURES_FORWARD_REF(t_STD_VARIANT) original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) t,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class t_ARGS_01,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01))
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il,
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01))
    {
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  1u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01>::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01))
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  1u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01>::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   il,
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01))
    {
    }
 
    template <class FIRST = t_HEAD,
              class       = typename bsl::enable_if_t<
                  std::is_default_constructible<FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }
 
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<FIRST, t_TAIL_01>::value> >
    variant(bsl::allocator_arg_t,
            allocator_type allocator,
            const variant& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, original)
    {
    }
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<FIRST, t_TAIL_01>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator, variant&& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, std::move(original))
    {
    }
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  bsl::allocator_arg_t,
                  allocator_type  allocator,
                  BSLS_COMPILERFEATURES_FORWARD_REF(t_STD_VARIANT) original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(bsl::allocator_arg_t(),
                   allocator,
                   BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) t,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class t_ARGS_01,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01)
    : Variant_Base(
          bsl::allocator_arg_t{}
,
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          std::forward<t_ARGS_01>(args_01))
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01)
    : Variant_Base(
          bsl::allocator_arg_t{}
,
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il,
          std::forward<t_ARGS_01>(args_01))
    {
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  1u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01)
    : Variant_Base(bsl::allocator_arg_t{}
,
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   std::forward<t_ARGS_01>(args_01))
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  1u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01)
    : Variant_Base(bsl::allocator_arg_t{}
,
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   il,
                   std::forward<t_ARGS_01>(args_01))
    {
    }
 
#else
 
    variant();
 
    variant(const variant& original);
 
    variant(BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(const t_TYPE&                                              value,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     const t_ARG_03&                                   arg_03,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::in_place_index_t<t_INDEX>, const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
    variant(bsl::allocator_arg_t, allocator_type allocator);
 
    variant(bsl::allocator_arg_t,
            allocator_type       allocator,
            const variant&       original);
    variant(bsl::allocator_arg_t,
            allocator_type                          allocator,
            BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          const t_TYPE&                                              value,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   const t_ARG_03&                                   arg_03,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
#endif
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_TYPE,
              class t_ARGS_01,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01>::value> >
    t_TYPE& emplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01));
 
        return bsl::get<index>(*this);
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01>::value> >
    t_TYPE& emplace(std::initializer_list<INIT_LIST_TYPE> il,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            il, BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01));
 
        return bsl::get<index>(*this);
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  1u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01>::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01> >::type&
    emplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01));
 
        return bsl::get<t_INDEX>(*this);
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  1u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01>::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01> >::type&
    emplace(std::initializer_list<INIT_LIST_TYPE> il,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            il, BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01));
 
        return bsl::get<t_INDEX>(*this);
    }
 
#else
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace();
 
    template <class t_TYPE, class t_ARG_01>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
 
    template <size_t t_INDEX>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01> >::type&
    emplace();
 
    template <size_t t_INDEX, class t_ARG_01>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01> >::type&
    emplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01> >::type&
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
#endif
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    variant& operator=(const variant& rhs) = default;
 
    variant& operator=(variant&& rhs) = default;
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) value)
    {
        const size_t altIndex =
            BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
        if (index() == altIndex) {
            bsl::get<altIndex>(*this) = BSLS_COMPILERFEATURES_FORWARD(t_TYPE,
                                        value);
        }
        else {
            Variant_Base::template baseEmplace<altIndex>(
                BSLS_COMPILERFEATURES_FORWARD(t_TYPE, value));
        }
 
        return *this;
    }
#else
    variant& operator=(const variant& rhs);
 
    variant& operator=(BloombergLP::bslmf::MovableRef<variant> rhs);
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(const t_TYPE& value);
 
#endif
 
    void swap(variant& other);
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <bool t_USES_BSLMA_ALLOC = BloombergLP::bslstl::
                  Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01>::value,
              class = typename bsl::enable_if_t<t_USES_BSLMA_ALLOC> >
#endif
    allocator_type get_allocator() const BSLS_KEYWORD_NOEXCEPT
    {
        return allocator_type(Variant_Base::AllocBase::mechanism());
    }
 
 
    size_t index() const BSLS_KEYWORD_NOEXCEPT;
 
    bool valueless_by_exception() const BSLS_KEYWORD_NOEXCEPT;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
class variant<t_HEAD, t_TAIL_01,
                      t_TAIL_02>
: private BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02>
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
,
  private BloombergLP::bslstl::Variant_SMFBase<
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02>::value,
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02>::value &&
          BloombergLP::bslstl::Variant_IsCopyAssignableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02>::value &&
          BloombergLP::bslstl::Variant_IsMoveAssignableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02>::value>
#endif
{
  private:
    typedef BloombergLP::bslmf::MovableRefUtil                   MoveUtil;
    typedef BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02> Variant_Base;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02>
        Variant_Union;
 
    friend struct BloombergLP::bslstl::Variant_ImpUtil;
 
    friend struct BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                            t_TAIL_02>;
 
  public:
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02>::value));
 
 
    typedef typename Variant_Base::allocator_type allocator_type;
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_FIRST_ALT = t_HEAD,
              class             = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST_ALT>::value> >
    variant()
    : Variant_Base()
    {
    }
 
    variant(const variant& original) = default;
 
    variant(variant&& original) = default;
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  BSLS_COMPILERFEATURES_FORWARD_REF(t_STD_VARIANT) original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) t,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02))
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il,
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02))
    {
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  2u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02>::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02))
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  2u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02>::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   il,
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02))
    {
    }
 
    template <class FIRST = t_HEAD,
              class       = typename bsl::enable_if_t<
                  std::is_default_constructible<FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }
 
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<FIRST, t_TAIL_01,
                                                      t_TAIL_02>::value> >
    variant(bsl::allocator_arg_t,
            allocator_type allocator,
            const variant& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, original)
    {
    }
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<FIRST, t_TAIL_01,
                                                      t_TAIL_02>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator, variant&& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, std::move(original))
    {
    }
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  bsl::allocator_arg_t,
                  allocator_type  allocator,
                  BSLS_COMPILERFEATURES_FORWARD_REF(t_STD_VARIANT) original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(bsl::allocator_arg_t(),
                   allocator,
                   BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) t,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02)
    : Variant_Base(
          bsl::allocator_arg_t{}
,
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          std::forward<t_ARGS_01>(args_01),
          std::forward<t_ARGS_02>(args_02))
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02)
    : Variant_Base(
          bsl::allocator_arg_t{}
,
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il,
          std::forward<t_ARGS_01>(args_01),
          std::forward<t_ARGS_02>(args_02))
    {
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  2u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02)
    : Variant_Base(bsl::allocator_arg_t{}
,
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   std::forward<t_ARGS_01>(args_01),
                   std::forward<t_ARGS_02>(args_02))
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  2u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02)
    : Variant_Base(bsl::allocator_arg_t{}
,
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   il,
                   std::forward<t_ARGS_01>(args_01),
                   std::forward<t_ARGS_02>(args_02))
    {
    }
 
#else
 
    variant();
 
    variant(const variant& original);
 
    variant(BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(const t_TYPE&                                              value,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     const t_ARG_03&                                   arg_03,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::in_place_index_t<t_INDEX>, const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
    variant(bsl::allocator_arg_t, allocator_type allocator);
 
    variant(bsl::allocator_arg_t,
            allocator_type       allocator,
            const variant&       original);
    variant(bsl::allocator_arg_t,
            allocator_type                          allocator,
            BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          const t_TYPE&                                              value,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   const t_ARG_03&                                   arg_03,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
#endif
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02>::value> >
    t_TYPE& emplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02));
 
        return bsl::get<index>(*this);
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02>::value> >
    t_TYPE& emplace(std::initializer_list<INIT_LIST_TYPE> il,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            il, BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02));
 
        return bsl::get<index>(*this);
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  2u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02>::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02> >::type&
    emplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02));
 
        return bsl::get<t_INDEX>(*this);
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  2u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02>::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02> >::type&
    emplace(std::initializer_list<INIT_LIST_TYPE> il,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            il, BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02));
 
        return bsl::get<t_INDEX>(*this);
    }
 
#else
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace();
 
    template <class t_TYPE, class t_ARG_01>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
 
    template <size_t t_INDEX>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02> >::type&
    emplace();
 
    template <size_t t_INDEX, class t_ARG_01>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02> >::type&
    emplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02> >::type&
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
#endif
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    variant& operator=(const variant& rhs) = default;
 
    variant& operator=(variant&& rhs) = default;
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) value)
    {
        const size_t altIndex =
            BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
        if (index() == altIndex) {
            bsl::get<altIndex>(*this) = BSLS_COMPILERFEATURES_FORWARD(t_TYPE,
                                        value);
        }
        else {
            Variant_Base::template baseEmplace<altIndex>(
                BSLS_COMPILERFEATURES_FORWARD(t_TYPE, value));
        }
 
        return *this;
    }
#else
    variant& operator=(const variant& rhs);
 
    variant& operator=(BloombergLP::bslmf::MovableRef<variant> rhs);
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(const t_TYPE& value);
 
#endif
 
    void swap(variant& other);
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <bool t_USES_BSLMA_ALLOC = BloombergLP::bslstl::
                  Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02>::value,
              class = typename bsl::enable_if_t<t_USES_BSLMA_ALLOC> >
#endif
    allocator_type get_allocator() const BSLS_KEYWORD_NOEXCEPT
    {
        return allocator_type(Variant_Base::AllocBase::mechanism());
    }
 
 
    size_t index() const BSLS_KEYWORD_NOEXCEPT;
 
    bool valueless_by_exception() const BSLS_KEYWORD_NOEXCEPT;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
class variant<t_HEAD, t_TAIL_01,
                      t_TAIL_02,
                      t_TAIL_03>
: private BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03>
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
,
  private BloombergLP::bslstl::Variant_SMFBase<
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03>::value,
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03>::value &&
          BloombergLP::bslstl::Variant_IsCopyAssignableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03>::value &&
          BloombergLP::bslstl::Variant_IsMoveAssignableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03>::value>
#endif
{
  private:
    typedef BloombergLP::bslmf::MovableRefUtil                   MoveUtil;
    typedef BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03> Variant_Base;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03>
        Variant_Union;
 
    friend struct BloombergLP::bslstl::Variant_ImpUtil;
 
    friend struct BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                            t_TAIL_02,
                                                            t_TAIL_03>;
 
  public:
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03>::value));
 
 
    typedef typename Variant_Base::allocator_type allocator_type;
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_FIRST_ALT = t_HEAD,
              class             = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST_ALT>::value> >
    variant()
    : Variant_Base()
    {
    }
 
    variant(const variant& original) = default;
 
    variant(variant&& original) = default;
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  BSLS_COMPILERFEATURES_FORWARD_REF(t_STD_VARIANT) original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) t,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03))
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il,
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03))
    {
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  3u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03>::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03))
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  3u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03>::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   il,
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03))
    {
    }
 
    template <class FIRST = t_HEAD,
              class       = typename bsl::enable_if_t<
                  std::is_default_constructible<FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }
 
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<FIRST, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03>::value> >
    variant(bsl::allocator_arg_t,
            allocator_type allocator,
            const variant& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, original)
    {
    }
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<FIRST, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator, variant&& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, std::move(original))
    {
    }
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  bsl::allocator_arg_t,
                  allocator_type  allocator,
                  BSLS_COMPILERFEATURES_FORWARD_REF(t_STD_VARIANT) original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(bsl::allocator_arg_t(),
                   allocator,
                   BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) t,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03)
    : Variant_Base(
          bsl::allocator_arg_t{}
,
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          std::forward<t_ARGS_01>(args_01),
          std::forward<t_ARGS_02>(args_02),
          std::forward<t_ARGS_03>(args_03))
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03)
    : Variant_Base(
          bsl::allocator_arg_t{}
,
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il,
          std::forward<t_ARGS_01>(args_01),
          std::forward<t_ARGS_02>(args_02),
          std::forward<t_ARGS_03>(args_03))
    {
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  3u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03)
    : Variant_Base(bsl::allocator_arg_t{}
,
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   std::forward<t_ARGS_01>(args_01),
                   std::forward<t_ARGS_02>(args_02),
                   std::forward<t_ARGS_03>(args_03))
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  3u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03)
    : Variant_Base(bsl::allocator_arg_t{}
,
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   il,
                   std::forward<t_ARGS_01>(args_01),
                   std::forward<t_ARGS_02>(args_02),
                   std::forward<t_ARGS_03>(args_03))
    {
    }
 
#else
 
    variant();
 
    variant(const variant& original);
 
    variant(BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(const t_TYPE&                                              value,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     const t_ARG_03&                                   arg_03,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::in_place_index_t<t_INDEX>, const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
    variant(bsl::allocator_arg_t, allocator_type allocator);
 
    variant(bsl::allocator_arg_t,
            allocator_type       allocator,
            const variant&       original);
    variant(bsl::allocator_arg_t,
            allocator_type                          allocator,
            BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          const t_TYPE&                                              value,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   const t_ARG_03&                                   arg_03,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
#endif
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03>::value> >
    t_TYPE& emplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03));
 
        return bsl::get<index>(*this);
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03>::value> >
    t_TYPE& emplace(std::initializer_list<INIT_LIST_TYPE> il,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            il, BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03));
 
        return bsl::get<index>(*this);
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  3u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03>::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03> >::type&
    emplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03));
 
        return bsl::get<t_INDEX>(*this);
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  3u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03>::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03> >::type&
    emplace(std::initializer_list<INIT_LIST_TYPE> il,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            il, BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03));
 
        return bsl::get<t_INDEX>(*this);
    }
 
#else
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace();
 
    template <class t_TYPE, class t_ARG_01>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
 
    template <size_t t_INDEX>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03> >::type&
    emplace();
 
    template <size_t t_INDEX, class t_ARG_01>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03> >::type&
    emplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03> >::type&
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
#endif
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    variant& operator=(const variant& rhs) = default;
 
    variant& operator=(variant&& rhs) = default;
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) value)
    {
        const size_t altIndex =
            BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
        if (index() == altIndex) {
            bsl::get<altIndex>(*this) = BSLS_COMPILERFEATURES_FORWARD(t_TYPE,
                                        value);
        }
        else {
            Variant_Base::template baseEmplace<altIndex>(
                BSLS_COMPILERFEATURES_FORWARD(t_TYPE, value));
        }
 
        return *this;
    }
#else
    variant& operator=(const variant& rhs);
 
    variant& operator=(BloombergLP::bslmf::MovableRef<variant> rhs);
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(const t_TYPE& value);
 
#endif
 
    void swap(variant& other);
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <bool t_USES_BSLMA_ALLOC = BloombergLP::bslstl::
                  Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03>::value,
              class = typename bsl::enable_if_t<t_USES_BSLMA_ALLOC> >
#endif
    allocator_type get_allocator() const BSLS_KEYWORD_NOEXCEPT
    {
        return allocator_type(Variant_Base::AllocBase::mechanism());
    }
 
 
    size_t index() const BSLS_KEYWORD_NOEXCEPT;
 
    bool valueless_by_exception() const BSLS_KEYWORD_NOEXCEPT;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
class variant<t_HEAD, t_TAIL_01,
                      t_TAIL_02,
                      t_TAIL_03,
                      t_TAIL_04>
: private BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04>
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
,
  private BloombergLP::bslstl::Variant_SMFBase<
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04>::value,
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04>::value &&
          BloombergLP::bslstl::Variant_IsCopyAssignableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04>::value &&
          BloombergLP::bslstl::Variant_IsMoveAssignableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04>::value>
#endif
{
  private:
    typedef BloombergLP::bslmf::MovableRefUtil                   MoveUtil;
    typedef BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04> Variant_Base;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04>
        Variant_Union;
 
    friend struct BloombergLP::bslstl::Variant_ImpUtil;
 
    friend struct BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                            t_TAIL_02,
                                                            t_TAIL_03,
                                                            t_TAIL_04>;
 
  public:
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04>::value));
 
 
    typedef typename Variant_Base::allocator_type allocator_type;
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_FIRST_ALT = t_HEAD,
              class             = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST_ALT>::value> >
    variant()
    : Variant_Base()
    {
    }
 
    variant(const variant& original) = default;
 
    variant(variant&& original) = default;
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  BSLS_COMPILERFEATURES_FORWARD_REF(t_STD_VARIANT) original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) t,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04))
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il,
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04))
    {
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  4u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04>::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04))
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  4u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04>::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   il,
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04))
    {
    }
 
    template <class FIRST = t_HEAD,
              class       = typename bsl::enable_if_t<
                  std::is_default_constructible<FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }
 
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<FIRST, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04>::value> >
    variant(bsl::allocator_arg_t,
            allocator_type allocator,
            const variant& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, original)
    {
    }
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<FIRST, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator, variant&& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, std::move(original))
    {
    }
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  bsl::allocator_arg_t,
                  allocator_type  allocator,
                  BSLS_COMPILERFEATURES_FORWARD_REF(t_STD_VARIANT) original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(bsl::allocator_arg_t(),
                   allocator,
                   BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) t,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04)
    : Variant_Base(
          bsl::allocator_arg_t{}
,
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          std::forward<t_ARGS_01>(args_01),
          std::forward<t_ARGS_02>(args_02),
          std::forward<t_ARGS_03>(args_03),
          std::forward<t_ARGS_04>(args_04))
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04)
    : Variant_Base(
          bsl::allocator_arg_t{}
,
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il,
          std::forward<t_ARGS_01>(args_01),
          std::forward<t_ARGS_02>(args_02),
          std::forward<t_ARGS_03>(args_03),
          std::forward<t_ARGS_04>(args_04))
    {
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  4u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04)
    : Variant_Base(bsl::allocator_arg_t{}
,
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   std::forward<t_ARGS_01>(args_01),
                   std::forward<t_ARGS_02>(args_02),
                   std::forward<t_ARGS_03>(args_03),
                   std::forward<t_ARGS_04>(args_04))
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  4u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04)
    : Variant_Base(bsl::allocator_arg_t{}
,
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   il,
                   std::forward<t_ARGS_01>(args_01),
                   std::forward<t_ARGS_02>(args_02),
                   std::forward<t_ARGS_03>(args_03),
                   std::forward<t_ARGS_04>(args_04))
    {
    }
 
#else
 
    variant();
 
    variant(const variant& original);
 
    variant(BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(const t_TYPE&                                              value,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     const t_ARG_03&                                   arg_03,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::in_place_index_t<t_INDEX>, const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
    variant(bsl::allocator_arg_t, allocator_type allocator);
 
    variant(bsl::allocator_arg_t,
            allocator_type       allocator,
            const variant&       original);
    variant(bsl::allocator_arg_t,
            allocator_type                          allocator,
            BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          const t_TYPE&                                              value,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   const t_ARG_03&                                   arg_03,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
#endif
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04>::value> >
    t_TYPE& emplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04));
 
        return bsl::get<index>(*this);
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04>::value> >
    t_TYPE& emplace(std::initializer_list<INIT_LIST_TYPE> il,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            il, BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04));
 
        return bsl::get<index>(*this);
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  4u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04>::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04> >::type&
    emplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04));
 
        return bsl::get<t_INDEX>(*this);
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  4u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04>::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04> >::type&
    emplace(std::initializer_list<INIT_LIST_TYPE> il,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            il, BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04));
 
        return bsl::get<t_INDEX>(*this);
    }
 
#else
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace();
 
    template <class t_TYPE, class t_ARG_01>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
 
    template <size_t t_INDEX>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04> >::type&
    emplace();
 
    template <size_t t_INDEX, class t_ARG_01>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04> >::type&
    emplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04> >::type&
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
#endif
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    variant& operator=(const variant& rhs) = default;
 
    variant& operator=(variant&& rhs) = default;
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) value)
    {
        const size_t altIndex =
            BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
        if (index() == altIndex) {
            bsl::get<altIndex>(*this) = BSLS_COMPILERFEATURES_FORWARD(t_TYPE,
                                        value);
        }
        else {
            Variant_Base::template baseEmplace<altIndex>(
                BSLS_COMPILERFEATURES_FORWARD(t_TYPE, value));
        }
 
        return *this;
    }
#else
    variant& operator=(const variant& rhs);
 
    variant& operator=(BloombergLP::bslmf::MovableRef<variant> rhs);
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(const t_TYPE& value);
 
#endif
 
    void swap(variant& other);
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <bool t_USES_BSLMA_ALLOC = BloombergLP::bslstl::
                  Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04>::value,
              class = typename bsl::enable_if_t<t_USES_BSLMA_ALLOC> >
#endif
    allocator_type get_allocator() const BSLS_KEYWORD_NOEXCEPT
    {
        return allocator_type(Variant_Base::AllocBase::mechanism());
    }
 
 
    size_t index() const BSLS_KEYWORD_NOEXCEPT;
 
    bool valueless_by_exception() const BSLS_KEYWORD_NOEXCEPT;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
class variant<t_HEAD, t_TAIL_01,
                      t_TAIL_02,
                      t_TAIL_03,
                      t_TAIL_04,
                      t_TAIL_05>
: private BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05>
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
,
  private BloombergLP::bslstl::Variant_SMFBase<
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05>::value,
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05>::value &&
          BloombergLP::bslstl::Variant_IsCopyAssignableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05>::value &&
          BloombergLP::bslstl::Variant_IsMoveAssignableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05>::value>
#endif
{
  private:
    typedef BloombergLP::bslmf::MovableRefUtil                   MoveUtil;
    typedef BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05> Variant_Base;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05>
        Variant_Union;
 
    friend struct BloombergLP::bslstl::Variant_ImpUtil;
 
    friend struct BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                            t_TAIL_02,
                                                            t_TAIL_03,
                                                            t_TAIL_04,
                                                            t_TAIL_05>;
 
  public:
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05>::value));
 
 
    typedef typename Variant_Base::allocator_type allocator_type;
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_FIRST_ALT = t_HEAD,
              class             = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST_ALT>::value> >
    variant()
    : Variant_Base()
    {
    }
 
    variant(const variant& original) = default;
 
    variant(variant&& original) = default;
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  BSLS_COMPILERFEATURES_FORWARD_REF(t_STD_VARIANT) original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) t,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05))
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il,
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05))
    {
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  5u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05>::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05))
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  5u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05>::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   il,
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05))
    {
    }
 
    template <class FIRST = t_HEAD,
              class       = typename bsl::enable_if_t<
                  std::is_default_constructible<FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }
 
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<FIRST, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05>::value> >
    variant(bsl::allocator_arg_t,
            allocator_type allocator,
            const variant& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, original)
    {
    }
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<FIRST, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator, variant&& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, std::move(original))
    {
    }
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  bsl::allocator_arg_t,
                  allocator_type  allocator,
                  BSLS_COMPILERFEATURES_FORWARD_REF(t_STD_VARIANT) original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(bsl::allocator_arg_t(),
                   allocator,
                   BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) t,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05)
    : Variant_Base(
          bsl::allocator_arg_t{}
,
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          std::forward<t_ARGS_01>(args_01),
          std::forward<t_ARGS_02>(args_02),
          std::forward<t_ARGS_03>(args_03),
          std::forward<t_ARGS_04>(args_04),
          std::forward<t_ARGS_05>(args_05))
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05)
    : Variant_Base(
          bsl::allocator_arg_t{}
,
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il,
          std::forward<t_ARGS_01>(args_01),
          std::forward<t_ARGS_02>(args_02),
          std::forward<t_ARGS_03>(args_03),
          std::forward<t_ARGS_04>(args_04),
          std::forward<t_ARGS_05>(args_05))
    {
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  5u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05)
    : Variant_Base(bsl::allocator_arg_t{}
,
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   std::forward<t_ARGS_01>(args_01),
                   std::forward<t_ARGS_02>(args_02),
                   std::forward<t_ARGS_03>(args_03),
                   std::forward<t_ARGS_04>(args_04),
                   std::forward<t_ARGS_05>(args_05))
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  5u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05)
    : Variant_Base(bsl::allocator_arg_t{}
,
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   il,
                   std::forward<t_ARGS_01>(args_01),
                   std::forward<t_ARGS_02>(args_02),
                   std::forward<t_ARGS_03>(args_03),
                   std::forward<t_ARGS_04>(args_04),
                   std::forward<t_ARGS_05>(args_05))
    {
    }
 
#else
 
    variant();
 
    variant(const variant& original);
 
    variant(BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(const t_TYPE&                                              value,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     const t_ARG_03&                                   arg_03,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::in_place_index_t<t_INDEX>, const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
    variant(bsl::allocator_arg_t, allocator_type allocator);
 
    variant(bsl::allocator_arg_t,
            allocator_type       allocator,
            const variant&       original);
    variant(bsl::allocator_arg_t,
            allocator_type                          allocator,
            BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          const t_TYPE&                                              value,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   const t_ARG_03&                                   arg_03,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
#endif
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05>::value> >
    t_TYPE& emplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05));
 
        return bsl::get<index>(*this);
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05>::value> >
    t_TYPE& emplace(std::initializer_list<INIT_LIST_TYPE> il,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            il, BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05));
 
        return bsl::get<index>(*this);
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  5u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05>::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05> >::type&
    emplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05));
 
        return bsl::get<t_INDEX>(*this);
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  5u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05>::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05> >::type&
    emplace(std::initializer_list<INIT_LIST_TYPE> il,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            il, BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05));
 
        return bsl::get<t_INDEX>(*this);
    }
 
#else
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace();
 
    template <class t_TYPE, class t_ARG_01>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
 
    template <size_t t_INDEX>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05> >::type&
    emplace();
 
    template <size_t t_INDEX, class t_ARG_01>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05> >::type&
    emplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05> >::type&
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
#endif
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    variant& operator=(const variant& rhs) = default;
 
    variant& operator=(variant&& rhs) = default;
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) value)
    {
        const size_t altIndex =
            BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
        if (index() == altIndex) {
            bsl::get<altIndex>(*this) = BSLS_COMPILERFEATURES_FORWARD(t_TYPE,
                                        value);
        }
        else {
            Variant_Base::template baseEmplace<altIndex>(
                BSLS_COMPILERFEATURES_FORWARD(t_TYPE, value));
        }
 
        return *this;
    }
#else
    variant& operator=(const variant& rhs);
 
    variant& operator=(BloombergLP::bslmf::MovableRef<variant> rhs);
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(const t_TYPE& value);
 
#endif
 
    void swap(variant& other);
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <bool t_USES_BSLMA_ALLOC = BloombergLP::bslstl::
                  Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05>::value,
              class = typename bsl::enable_if_t<t_USES_BSLMA_ALLOC> >
#endif
    allocator_type get_allocator() const BSLS_KEYWORD_NOEXCEPT
    {
        return allocator_type(Variant_Base::AllocBase::mechanism());
    }
 
 
    size_t index() const BSLS_KEYWORD_NOEXCEPT;
 
    bool valueless_by_exception() const BSLS_KEYWORD_NOEXCEPT;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
class variant<t_HEAD, t_TAIL_01,
                      t_TAIL_02,
                      t_TAIL_03,
                      t_TAIL_04,
                      t_TAIL_05,
                      t_TAIL_06>
: private BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06>
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
,
  private BloombergLP::bslstl::Variant_SMFBase<
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06>::value,
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06>::value &&
          BloombergLP::bslstl::Variant_IsCopyAssignableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06>::value &&
          BloombergLP::bslstl::Variant_IsMoveAssignableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06>::value>
#endif
{
  private:
    typedef BloombergLP::bslmf::MovableRefUtil                   MoveUtil;
    typedef BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06> Variant_Base;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06>
        Variant_Union;
 
    friend struct BloombergLP::bslstl::Variant_ImpUtil;
 
    friend struct BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                            t_TAIL_02,
                                                            t_TAIL_03,
                                                            t_TAIL_04,
                                                            t_TAIL_05,
                                                            t_TAIL_06>;
 
  public:
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06>::value));
 
 
    typedef typename Variant_Base::allocator_type allocator_type;
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_FIRST_ALT = t_HEAD,
              class             = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST_ALT>::value> >
    variant()
    : Variant_Base()
    {
    }
 
    variant(const variant& original) = default;
 
    variant(variant&& original) = default;
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  BSLS_COMPILERFEATURES_FORWARD_REF(t_STD_VARIANT) original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) t,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06))
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il,
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06))
    {
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  6u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06>::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06))
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  6u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06>::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   il,
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06))
    {
    }
 
    template <class FIRST = t_HEAD,
              class       = typename bsl::enable_if_t<
                  std::is_default_constructible<FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }
 
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<FIRST, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06>::value> >
    variant(bsl::allocator_arg_t,
            allocator_type allocator,
            const variant& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, original)
    {
    }
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<FIRST, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator, variant&& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, std::move(original))
    {
    }
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  bsl::allocator_arg_t,
                  allocator_type  allocator,
                  BSLS_COMPILERFEATURES_FORWARD_REF(t_STD_VARIANT) original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(bsl::allocator_arg_t(),
                   allocator,
                   BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) t,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06)
    : Variant_Base(
          bsl::allocator_arg_t{}
,
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          std::forward<t_ARGS_01>(args_01),
          std::forward<t_ARGS_02>(args_02),
          std::forward<t_ARGS_03>(args_03),
          std::forward<t_ARGS_04>(args_04),
          std::forward<t_ARGS_05>(args_05),
          std::forward<t_ARGS_06>(args_06))
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06)
    : Variant_Base(
          bsl::allocator_arg_t{}
,
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il,
          std::forward<t_ARGS_01>(args_01),
          std::forward<t_ARGS_02>(args_02),
          std::forward<t_ARGS_03>(args_03),
          std::forward<t_ARGS_04>(args_04),
          std::forward<t_ARGS_05>(args_05),
          std::forward<t_ARGS_06>(args_06))
    {
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  6u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06)
    : Variant_Base(bsl::allocator_arg_t{}
,
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   std::forward<t_ARGS_01>(args_01),
                   std::forward<t_ARGS_02>(args_02),
                   std::forward<t_ARGS_03>(args_03),
                   std::forward<t_ARGS_04>(args_04),
                   std::forward<t_ARGS_05>(args_05),
                   std::forward<t_ARGS_06>(args_06))
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  6u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06)
    : Variant_Base(bsl::allocator_arg_t{}
,
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   il,
                   std::forward<t_ARGS_01>(args_01),
                   std::forward<t_ARGS_02>(args_02),
                   std::forward<t_ARGS_03>(args_03),
                   std::forward<t_ARGS_04>(args_04),
                   std::forward<t_ARGS_05>(args_05),
                   std::forward<t_ARGS_06>(args_06))
    {
    }
 
#else
 
    variant();
 
    variant(const variant& original);
 
    variant(BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(const t_TYPE&                                              value,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     const t_ARG_03&                                   arg_03,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::in_place_index_t<t_INDEX>, const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
    variant(bsl::allocator_arg_t, allocator_type allocator);
 
    variant(bsl::allocator_arg_t,
            allocator_type       allocator,
            const variant&       original);
    variant(bsl::allocator_arg_t,
            allocator_type                          allocator,
            BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          const t_TYPE&                                              value,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   const t_ARG_03&                                   arg_03,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
#endif
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06>::value> >
    t_TYPE& emplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06));
 
        return bsl::get<index>(*this);
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06>::value> >
    t_TYPE& emplace(std::initializer_list<INIT_LIST_TYPE> il,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            il, BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06));
 
        return bsl::get<index>(*this);
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  6u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06>::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06> >::type&
    emplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06));
 
        return bsl::get<t_INDEX>(*this);
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  6u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06>::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06> >::type&
    emplace(std::initializer_list<INIT_LIST_TYPE> il,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            il, BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06));
 
        return bsl::get<t_INDEX>(*this);
    }
 
#else
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace();
 
    template <class t_TYPE, class t_ARG_01>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
 
    template <size_t t_INDEX>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06> >::type&
    emplace();
 
    template <size_t t_INDEX, class t_ARG_01>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06> >::type&
    emplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06> >::type&
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
#endif
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    variant& operator=(const variant& rhs) = default;
 
    variant& operator=(variant&& rhs) = default;
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) value)
    {
        const size_t altIndex =
            BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
        if (index() == altIndex) {
            bsl::get<altIndex>(*this) = BSLS_COMPILERFEATURES_FORWARD(t_TYPE,
                                        value);
        }
        else {
            Variant_Base::template baseEmplace<altIndex>(
                BSLS_COMPILERFEATURES_FORWARD(t_TYPE, value));
        }
 
        return *this;
    }
#else
    variant& operator=(const variant& rhs);
 
    variant& operator=(BloombergLP::bslmf::MovableRef<variant> rhs);
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(const t_TYPE& value);
 
#endif
 
    void swap(variant& other);
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <bool t_USES_BSLMA_ALLOC = BloombergLP::bslstl::
                  Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06>::value,
              class = typename bsl::enable_if_t<t_USES_BSLMA_ALLOC> >
#endif
    allocator_type get_allocator() const BSLS_KEYWORD_NOEXCEPT
    {
        return allocator_type(Variant_Base::AllocBase::mechanism());
    }
 
 
    size_t index() const BSLS_KEYWORD_NOEXCEPT;
 
    bool valueless_by_exception() const BSLS_KEYWORD_NOEXCEPT;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
class variant<t_HEAD, t_TAIL_01,
                      t_TAIL_02,
                      t_TAIL_03,
                      t_TAIL_04,
                      t_TAIL_05,
                      t_TAIL_06,
                      t_TAIL_07>
: private BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06,
                                                    t_TAIL_07>
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
,
  private BloombergLP::bslstl::Variant_SMFBase<
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07>::value,
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07>::value &&
          BloombergLP::bslstl::Variant_IsCopyAssignableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07>::value &&
          BloombergLP::bslstl::Variant_IsMoveAssignableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07>::value>
#endif
{
  private:
    typedef BloombergLP::bslmf::MovableRefUtil                   MoveUtil;
    typedef BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07> Variant_Base;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07>
        Variant_Union;
 
    friend struct BloombergLP::bslstl::Variant_ImpUtil;
 
    friend struct BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                            t_TAIL_02,
                                                            t_TAIL_03,
                                                            t_TAIL_04,
                                                            t_TAIL_05,
                                                            t_TAIL_06,
                                                            t_TAIL_07>;
 
  public:
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07>::value));
 
 
    typedef typename Variant_Base::allocator_type allocator_type;
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_FIRST_ALT = t_HEAD,
              class             = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST_ALT>::value> >
    variant()
    : Variant_Base()
    {
    }
 
    variant(const variant& original) = default;
 
    variant(variant&& original) = default;
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  BSLS_COMPILERFEATURES_FORWARD_REF(t_STD_VARIANT) original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) t,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06,
                                                t_ARGS_07>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07))
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il,
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07))
    {
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  7u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07>::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07))
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  7u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07>::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   il,
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07))
    {
    }
 
    template <class FIRST = t_HEAD,
              class       = typename bsl::enable_if_t<
                  std::is_default_constructible<FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }
 
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<FIRST, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07>::value> >
    variant(bsl::allocator_arg_t,
            allocator_type allocator,
            const variant& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, original)
    {
    }
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<FIRST, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator, variant&& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, std::move(original))
    {
    }
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  bsl::allocator_arg_t,
                  allocator_type  allocator,
                  BSLS_COMPILERFEATURES_FORWARD_REF(t_STD_VARIANT) original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(bsl::allocator_arg_t(),
                   allocator,
                   BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) t,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06,
                                                t_ARGS_07>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07)
    : Variant_Base(
          bsl::allocator_arg_t{}
,
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          std::forward<t_ARGS_01>(args_01),
          std::forward<t_ARGS_02>(args_02),
          std::forward<t_ARGS_03>(args_03),
          std::forward<t_ARGS_04>(args_04),
          std::forward<t_ARGS_05>(args_05),
          std::forward<t_ARGS_06>(args_06),
          std::forward<t_ARGS_07>(args_07))
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07)
    : Variant_Base(
          bsl::allocator_arg_t{}
,
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il,
          std::forward<t_ARGS_01>(args_01),
          std::forward<t_ARGS_02>(args_02),
          std::forward<t_ARGS_03>(args_03),
          std::forward<t_ARGS_04>(args_04),
          std::forward<t_ARGS_05>(args_05),
          std::forward<t_ARGS_06>(args_06),
          std::forward<t_ARGS_07>(args_07))
    {
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  7u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07)
    : Variant_Base(bsl::allocator_arg_t{}
,
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   std::forward<t_ARGS_01>(args_01),
                   std::forward<t_ARGS_02>(args_02),
                   std::forward<t_ARGS_03>(args_03),
                   std::forward<t_ARGS_04>(args_04),
                   std::forward<t_ARGS_05>(args_05),
                   std::forward<t_ARGS_06>(args_06),
                   std::forward<t_ARGS_07>(args_07))
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  7u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07)
    : Variant_Base(bsl::allocator_arg_t{}
,
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   il,
                   std::forward<t_ARGS_01>(args_01),
                   std::forward<t_ARGS_02>(args_02),
                   std::forward<t_ARGS_03>(args_03),
                   std::forward<t_ARGS_04>(args_04),
                   std::forward<t_ARGS_05>(args_05),
                   std::forward<t_ARGS_06>(args_06),
                   std::forward<t_ARGS_07>(args_07))
    {
    }
 
#else
 
    variant();
 
    variant(const variant& original);
 
    variant(BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(const t_TYPE&                                              value,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     const t_ARG_03&                                   arg_03,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::in_place_index_t<t_INDEX>, const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
    variant(bsl::allocator_arg_t, allocator_type allocator);
 
    variant(bsl::allocator_arg_t,
            allocator_type       allocator,
            const variant&       original);
    variant(bsl::allocator_arg_t,
            allocator_type                          allocator,
            BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          const t_TYPE&                                              value,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   const t_ARG_03&                                   arg_03,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
#endif
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06,
                                                t_ARGS_07>::value> >
    t_TYPE& emplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07));
 
        return bsl::get<index>(*this);
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07>::value> >
    t_TYPE& emplace(std::initializer_list<INIT_LIST_TYPE> il,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            il, BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07));
 
        return bsl::get<index>(*this);
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  7u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07>::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07> >::type&
    emplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07));
 
        return bsl::get<t_INDEX>(*this);
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  7u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07>::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07> >::type&
    emplace(std::initializer_list<INIT_LIST_TYPE> il,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            il, BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07));
 
        return bsl::get<t_INDEX>(*this);
    }
 
#else
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace();
 
    template <class t_TYPE, class t_ARG_01>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
 
    template <size_t t_INDEX>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07> >::type&
    emplace();
 
    template <size_t t_INDEX, class t_ARG_01>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07> >::type&
    emplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07> >::type&
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
#endif
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    variant& operator=(const variant& rhs) = default;
 
    variant& operator=(variant&& rhs) = default;
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) value)
    {
        const size_t altIndex =
            BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
        if (index() == altIndex) {
            bsl::get<altIndex>(*this) = BSLS_COMPILERFEATURES_FORWARD(t_TYPE,
                                        value);
        }
        else {
            Variant_Base::template baseEmplace<altIndex>(
                BSLS_COMPILERFEATURES_FORWARD(t_TYPE, value));
        }
 
        return *this;
    }
#else
    variant& operator=(const variant& rhs);
 
    variant& operator=(BloombergLP::bslmf::MovableRef<variant> rhs);
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(const t_TYPE& value);
 
#endif
 
    void swap(variant& other);
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <bool t_USES_BSLMA_ALLOC = BloombergLP::bslstl::
                  Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07>::value,
              class = typename bsl::enable_if_t<t_USES_BSLMA_ALLOC> >
#endif
    allocator_type get_allocator() const BSLS_KEYWORD_NOEXCEPT
    {
        return allocator_type(Variant_Base::AllocBase::mechanism());
    }
 
 
    size_t index() const BSLS_KEYWORD_NOEXCEPT;
 
    bool valueless_by_exception() const BSLS_KEYWORD_NOEXCEPT;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
class variant<t_HEAD, t_TAIL_01,
                      t_TAIL_02,
                      t_TAIL_03,
                      t_TAIL_04,
                      t_TAIL_05,
                      t_TAIL_06,
                      t_TAIL_07,
                      t_TAIL_08>
: private BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06,
                                                    t_TAIL_07,
                                                    t_TAIL_08>
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
,
  private BloombergLP::bslstl::Variant_SMFBase<
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08>::value,
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08>::value &&
          BloombergLP::bslstl::Variant_IsCopyAssignableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08>::value &&
          BloombergLP::bslstl::Variant_IsMoveAssignableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08>::value>
#endif
{
  private:
    typedef BloombergLP::bslmf::MovableRefUtil                   MoveUtil;
    typedef BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08> Variant_Base;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08>
        Variant_Union;
 
    friend struct BloombergLP::bslstl::Variant_ImpUtil;
 
    friend struct BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                            t_TAIL_02,
                                                            t_TAIL_03,
                                                            t_TAIL_04,
                                                            t_TAIL_05,
                                                            t_TAIL_06,
                                                            t_TAIL_07,
                                                            t_TAIL_08>;
 
  public:
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08>::value));
 
 
    typedef typename Variant_Base::allocator_type allocator_type;
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_FIRST_ALT = t_HEAD,
              class             = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST_ALT>::value> >
    variant()
    : Variant_Base()
    {
    }
 
    variant(const variant& original) = default;
 
    variant(variant&& original) = default;
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  BSLS_COMPILERFEATURES_FORWARD_REF(t_STD_VARIANT) original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) t,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06,
                                                t_ARGS_07,
                                                t_ARGS_08>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08))
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il,
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08))
    {
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  8u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08>::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08))
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  8u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08>::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   il,
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08))
    {
    }
 
    template <class FIRST = t_HEAD,
              class       = typename bsl::enable_if_t<
                  std::is_default_constructible<FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }
 
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<FIRST, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08>::value> >
    variant(bsl::allocator_arg_t,
            allocator_type allocator,
            const variant& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, original)
    {
    }
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<FIRST, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator, variant&& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, std::move(original))
    {
    }
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  bsl::allocator_arg_t,
                  allocator_type  allocator,
                  BSLS_COMPILERFEATURES_FORWARD_REF(t_STD_VARIANT) original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(bsl::allocator_arg_t(),
                   allocator,
                   BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) t,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06,
                                                t_ARGS_07,
                                                t_ARGS_08>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08)
    : Variant_Base(
          bsl::allocator_arg_t{}
,
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          std::forward<t_ARGS_01>(args_01),
          std::forward<t_ARGS_02>(args_02),
          std::forward<t_ARGS_03>(args_03),
          std::forward<t_ARGS_04>(args_04),
          std::forward<t_ARGS_05>(args_05),
          std::forward<t_ARGS_06>(args_06),
          std::forward<t_ARGS_07>(args_07),
          std::forward<t_ARGS_08>(args_08))
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08)
    : Variant_Base(
          bsl::allocator_arg_t{}
,
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il,
          std::forward<t_ARGS_01>(args_01),
          std::forward<t_ARGS_02>(args_02),
          std::forward<t_ARGS_03>(args_03),
          std::forward<t_ARGS_04>(args_04),
          std::forward<t_ARGS_05>(args_05),
          std::forward<t_ARGS_06>(args_06),
          std::forward<t_ARGS_07>(args_07),
          std::forward<t_ARGS_08>(args_08))
    {
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  8u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08)
    : Variant_Base(bsl::allocator_arg_t{}
,
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   std::forward<t_ARGS_01>(args_01),
                   std::forward<t_ARGS_02>(args_02),
                   std::forward<t_ARGS_03>(args_03),
                   std::forward<t_ARGS_04>(args_04),
                   std::forward<t_ARGS_05>(args_05),
                   std::forward<t_ARGS_06>(args_06),
                   std::forward<t_ARGS_07>(args_07),
                   std::forward<t_ARGS_08>(args_08))
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  8u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08)
    : Variant_Base(bsl::allocator_arg_t{}
,
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   il,
                   std::forward<t_ARGS_01>(args_01),
                   std::forward<t_ARGS_02>(args_02),
                   std::forward<t_ARGS_03>(args_03),
                   std::forward<t_ARGS_04>(args_04),
                   std::forward<t_ARGS_05>(args_05),
                   std::forward<t_ARGS_06>(args_06),
                   std::forward<t_ARGS_07>(args_07),
                   std::forward<t_ARGS_08>(args_08))
    {
    }
 
#else
 
    variant();
 
    variant(const variant& original);
 
    variant(BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(const t_TYPE&                                              value,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     const t_ARG_03&                                   arg_03,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::in_place_index_t<t_INDEX>, const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
    variant(bsl::allocator_arg_t, allocator_type allocator);
 
    variant(bsl::allocator_arg_t,
            allocator_type       allocator,
            const variant&       original);
    variant(bsl::allocator_arg_t,
            allocator_type                          allocator,
            BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          const t_TYPE&                                              value,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   const t_ARG_03&                                   arg_03,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
#endif
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06,
                                                t_ARGS_07,
                                                t_ARGS_08>::value> >
    t_TYPE& emplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08));
 
        return bsl::get<index>(*this);
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08>::value> >
    t_TYPE& emplace(std::initializer_list<INIT_LIST_TYPE> il,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            il, BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08));
 
        return bsl::get<index>(*this);
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  8u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08>::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08> >::type&
    emplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08));
 
        return bsl::get<t_INDEX>(*this);
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  8u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08>::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08> >::type&
    emplace(std::initializer_list<INIT_LIST_TYPE> il,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            il, BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08));
 
        return bsl::get<t_INDEX>(*this);
    }
 
#else
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace();
 
    template <class t_TYPE, class t_ARG_01>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
 
    template <size_t t_INDEX>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08> >::type&
    emplace();
 
    template <size_t t_INDEX, class t_ARG_01>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08> >::type&
    emplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08> >::type&
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
#endif
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    variant& operator=(const variant& rhs) = default;
 
    variant& operator=(variant&& rhs) = default;
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) value)
    {
        const size_t altIndex =
            BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
        if (index() == altIndex) {
            bsl::get<altIndex>(*this) = BSLS_COMPILERFEATURES_FORWARD(t_TYPE,
                                        value);
        }
        else {
            Variant_Base::template baseEmplace<altIndex>(
                BSLS_COMPILERFEATURES_FORWARD(t_TYPE, value));
        }
 
        return *this;
    }
#else
    variant& operator=(const variant& rhs);
 
    variant& operator=(BloombergLP::bslmf::MovableRef<variant> rhs);
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(const t_TYPE& value);
 
#endif
 
    void swap(variant& other);
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <bool t_USES_BSLMA_ALLOC = BloombergLP::bslstl::
                  Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08>::value,
              class = typename bsl::enable_if_t<t_USES_BSLMA_ALLOC> >
#endif
    allocator_type get_allocator() const BSLS_KEYWORD_NOEXCEPT
    {
        return allocator_type(Variant_Base::AllocBase::mechanism());
    }
 
 
    size_t index() const BSLS_KEYWORD_NOEXCEPT;
 
    bool valueless_by_exception() const BSLS_KEYWORD_NOEXCEPT;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
class variant<t_HEAD, t_TAIL_01,
                      t_TAIL_02,
                      t_TAIL_03,
                      t_TAIL_04,
                      t_TAIL_05,
                      t_TAIL_06,
                      t_TAIL_07,
                      t_TAIL_08,
                      t_TAIL_09>
: private BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06,
                                                    t_TAIL_07,
                                                    t_TAIL_08,
                                                    t_TAIL_09>
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
,
  private BloombergLP::bslstl::Variant_SMFBase<
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09>::value,
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09>::value &&
          BloombergLP::bslstl::Variant_IsCopyAssignableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09>::value &&
          BloombergLP::bslstl::Variant_IsMoveAssignableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09>::value>
#endif
{
  private:
    typedef BloombergLP::bslmf::MovableRefUtil                   MoveUtil;
    typedef BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09> Variant_Base;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09>
        Variant_Union;
 
    friend struct BloombergLP::bslstl::Variant_ImpUtil;
 
    friend struct BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                            t_TAIL_02,
                                                            t_TAIL_03,
                                                            t_TAIL_04,
                                                            t_TAIL_05,
                                                            t_TAIL_06,
                                                            t_TAIL_07,
                                                            t_TAIL_08,
                                                            t_TAIL_09>;
 
  public:
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09>::value));
 
 
    typedef typename Variant_Base::allocator_type allocator_type;
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_FIRST_ALT = t_HEAD,
              class             = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST_ALT>::value> >
    variant()
    : Variant_Base()
    {
    }
 
    variant(const variant& original) = default;
 
    variant(variant&& original) = default;
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  BSLS_COMPILERFEATURES_FORWARD_REF(t_STD_VARIANT) original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) t,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06,
                                                t_ARGS_07,
                                                t_ARGS_08,
                                                t_ARGS_09>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09))
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il,
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09))
    {
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  9u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09>::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09))
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  9u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09>::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   il,
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09))
    {
    }
 
    template <class FIRST = t_HEAD,
              class       = typename bsl::enable_if_t<
                  std::is_default_constructible<FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }
 
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<FIRST, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09>::value> >
    variant(bsl::allocator_arg_t,
            allocator_type allocator,
            const variant& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, original)
    {
    }
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<FIRST, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator, variant&& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, std::move(original))
    {
    }
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  bsl::allocator_arg_t,
                  allocator_type  allocator,
                  BSLS_COMPILERFEATURES_FORWARD_REF(t_STD_VARIANT) original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(bsl::allocator_arg_t(),
                   allocator,
                   BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) t,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06,
                                                t_ARGS_07,
                                                t_ARGS_08,
                                                t_ARGS_09>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09)
    : Variant_Base(
          bsl::allocator_arg_t{}
,
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          std::forward<t_ARGS_01>(args_01),
          std::forward<t_ARGS_02>(args_02),
          std::forward<t_ARGS_03>(args_03),
          std::forward<t_ARGS_04>(args_04),
          std::forward<t_ARGS_05>(args_05),
          std::forward<t_ARGS_06>(args_06),
          std::forward<t_ARGS_07>(args_07),
          std::forward<t_ARGS_08>(args_08),
          std::forward<t_ARGS_09>(args_09))
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09)
    : Variant_Base(
          bsl::allocator_arg_t{}
,
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il,
          std::forward<t_ARGS_01>(args_01),
          std::forward<t_ARGS_02>(args_02),
          std::forward<t_ARGS_03>(args_03),
          std::forward<t_ARGS_04>(args_04),
          std::forward<t_ARGS_05>(args_05),
          std::forward<t_ARGS_06>(args_06),
          std::forward<t_ARGS_07>(args_07),
          std::forward<t_ARGS_08>(args_08),
          std::forward<t_ARGS_09>(args_09))
    {
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  9u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09)
    : Variant_Base(bsl::allocator_arg_t{}
,
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   std::forward<t_ARGS_01>(args_01),
                   std::forward<t_ARGS_02>(args_02),
                   std::forward<t_ARGS_03>(args_03),
                   std::forward<t_ARGS_04>(args_04),
                   std::forward<t_ARGS_05>(args_05),
                   std::forward<t_ARGS_06>(args_06),
                   std::forward<t_ARGS_07>(args_07),
                   std::forward<t_ARGS_08>(args_08),
                   std::forward<t_ARGS_09>(args_09))
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  9u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09)
    : Variant_Base(bsl::allocator_arg_t{}
,
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   il,
                   std::forward<t_ARGS_01>(args_01),
                   std::forward<t_ARGS_02>(args_02),
                   std::forward<t_ARGS_03>(args_03),
                   std::forward<t_ARGS_04>(args_04),
                   std::forward<t_ARGS_05>(args_05),
                   std::forward<t_ARGS_06>(args_06),
                   std::forward<t_ARGS_07>(args_07),
                   std::forward<t_ARGS_08>(args_08),
                   std::forward<t_ARGS_09>(args_09))
    {
    }
 
#else
 
    variant();
 
    variant(const variant& original);
 
    variant(BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(const t_TYPE&                                              value,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     const t_ARG_03&                                   arg_03,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::in_place_index_t<t_INDEX>, const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
    variant(bsl::allocator_arg_t, allocator_type allocator);
 
    variant(bsl::allocator_arg_t,
            allocator_type       allocator,
            const variant&       original);
    variant(bsl::allocator_arg_t,
            allocator_type                          allocator,
            BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          const t_TYPE&                                              value,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   const t_ARG_03&                                   arg_03,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
#endif
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06,
                                                t_ARGS_07,
                                                t_ARGS_08,
                                                t_ARGS_09>::value> >
    t_TYPE& emplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09));
 
        return bsl::get<index>(*this);
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09>::value> >
    t_TYPE& emplace(std::initializer_list<INIT_LIST_TYPE> il,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            il, BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09));
 
        return bsl::get<index>(*this);
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  9u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09>::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09> >::type&
    emplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09));
 
        return bsl::get<t_INDEX>(*this);
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 +  9u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09>::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09> >::type&
    emplace(std::initializer_list<INIT_LIST_TYPE> il,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            il, BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09));
 
        return bsl::get<t_INDEX>(*this);
    }
 
#else
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace();
 
    template <class t_TYPE, class t_ARG_01>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
 
    template <size_t t_INDEX>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09> >::type&
    emplace();
 
    template <size_t t_INDEX, class t_ARG_01>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09> >::type&
    emplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09> >::type&
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
#endif
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    variant& operator=(const variant& rhs) = default;
 
    variant& operator=(variant&& rhs) = default;
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) value)
    {
        const size_t altIndex =
            BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
        if (index() == altIndex) {
            bsl::get<altIndex>(*this) = BSLS_COMPILERFEATURES_FORWARD(t_TYPE,
                                        value);
        }
        else {
            Variant_Base::template baseEmplace<altIndex>(
                BSLS_COMPILERFEATURES_FORWARD(t_TYPE, value));
        }
 
        return *this;
    }
#else
    variant& operator=(const variant& rhs);
 
    variant& operator=(BloombergLP::bslmf::MovableRef<variant> rhs);
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(const t_TYPE& value);
 
#endif
 
    void swap(variant& other);
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <bool t_USES_BSLMA_ALLOC = BloombergLP::bslstl::
                  Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09>::value,
              class = typename bsl::enable_if_t<t_USES_BSLMA_ALLOC> >
#endif
    allocator_type get_allocator() const BSLS_KEYWORD_NOEXCEPT
    {
        return allocator_type(Variant_Base::AllocBase::mechanism());
    }
 
 
    size_t index() const BSLS_KEYWORD_NOEXCEPT;
 
    bool valueless_by_exception() const BSLS_KEYWORD_NOEXCEPT;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
class variant<t_HEAD, t_TAIL_01,
                      t_TAIL_02,
                      t_TAIL_03,
                      t_TAIL_04,
                      t_TAIL_05,
                      t_TAIL_06,
                      t_TAIL_07,
                      t_TAIL_08,
                      t_TAIL_09,
                      t_TAIL_10>
: private BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06,
                                                    t_TAIL_07,
                                                    t_TAIL_08,
                                                    t_TAIL_09,
                                                    t_TAIL_10>
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
,
  private BloombergLP::bslstl::Variant_SMFBase<
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10>::value,
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10>::value &&
          BloombergLP::bslstl::Variant_IsCopyAssignableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10>::value &&
          BloombergLP::bslstl::Variant_IsMoveAssignableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10>::value>
#endif
{
  private:
    typedef BloombergLP::bslmf::MovableRefUtil                   MoveUtil;
    typedef BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10> Variant_Base;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10>
        Variant_Union;
 
    friend struct BloombergLP::bslstl::Variant_ImpUtil;
 
    friend struct BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                            t_TAIL_02,
                                                            t_TAIL_03,
                                                            t_TAIL_04,
                                                            t_TAIL_05,
                                                            t_TAIL_06,
                                                            t_TAIL_07,
                                                            t_TAIL_08,
                                                            t_TAIL_09,
                                                            t_TAIL_10>;
 
  public:
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10>::value));
 
 
    typedef typename Variant_Base::allocator_type allocator_type;
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_FIRST_ALT = t_HEAD,
              class             = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST_ALT>::value> >
    variant()
    : Variant_Base()
    {
    }
 
    variant(const variant& original) = default;
 
    variant(variant&& original) = default;
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  BSLS_COMPILERFEATURES_FORWARD_REF(t_STD_VARIANT) original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) t,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06,
                                                t_ARGS_07,
                                                t_ARGS_08,
                                                t_ARGS_09,
                                                t_ARGS_10>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10))
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il,
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10))
    {
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 10u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10>::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10))
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 10u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10>::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   il,
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10))
    {
    }
 
    template <class FIRST = t_HEAD,
              class       = typename bsl::enable_if_t<
                  std::is_default_constructible<FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }
 
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<FIRST, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10>::value> >
    variant(bsl::allocator_arg_t,
            allocator_type allocator,
            const variant& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, original)
    {
    }
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<FIRST, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator, variant&& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, std::move(original))
    {
    }
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  bsl::allocator_arg_t,
                  allocator_type  allocator,
                  BSLS_COMPILERFEATURES_FORWARD_REF(t_STD_VARIANT) original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(bsl::allocator_arg_t(),
                   allocator,
                   BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) t,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06,
                                                t_ARGS_07,
                                                t_ARGS_08,
                                                t_ARGS_09,
                                                t_ARGS_10>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10)
    : Variant_Base(
          bsl::allocator_arg_t{}
,
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          std::forward<t_ARGS_01>(args_01),
          std::forward<t_ARGS_02>(args_02),
          std::forward<t_ARGS_03>(args_03),
          std::forward<t_ARGS_04>(args_04),
          std::forward<t_ARGS_05>(args_05),
          std::forward<t_ARGS_06>(args_06),
          std::forward<t_ARGS_07>(args_07),
          std::forward<t_ARGS_08>(args_08),
          std::forward<t_ARGS_09>(args_09),
          std::forward<t_ARGS_10>(args_10))
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10)
    : Variant_Base(
          bsl::allocator_arg_t{}
,
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il,
          std::forward<t_ARGS_01>(args_01),
          std::forward<t_ARGS_02>(args_02),
          std::forward<t_ARGS_03>(args_03),
          std::forward<t_ARGS_04>(args_04),
          std::forward<t_ARGS_05>(args_05),
          std::forward<t_ARGS_06>(args_06),
          std::forward<t_ARGS_07>(args_07),
          std::forward<t_ARGS_08>(args_08),
          std::forward<t_ARGS_09>(args_09),
          std::forward<t_ARGS_10>(args_10))
    {
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 10u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10)
    : Variant_Base(bsl::allocator_arg_t{}
,
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   std::forward<t_ARGS_01>(args_01),
                   std::forward<t_ARGS_02>(args_02),
                   std::forward<t_ARGS_03>(args_03),
                   std::forward<t_ARGS_04>(args_04),
                   std::forward<t_ARGS_05>(args_05),
                   std::forward<t_ARGS_06>(args_06),
                   std::forward<t_ARGS_07>(args_07),
                   std::forward<t_ARGS_08>(args_08),
                   std::forward<t_ARGS_09>(args_09),
                   std::forward<t_ARGS_10>(args_10))
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 10u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10)
    : Variant_Base(bsl::allocator_arg_t{}
,
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   il,
                   std::forward<t_ARGS_01>(args_01),
                   std::forward<t_ARGS_02>(args_02),
                   std::forward<t_ARGS_03>(args_03),
                   std::forward<t_ARGS_04>(args_04),
                   std::forward<t_ARGS_05>(args_05),
                   std::forward<t_ARGS_06>(args_06),
                   std::forward<t_ARGS_07>(args_07),
                   std::forward<t_ARGS_08>(args_08),
                   std::forward<t_ARGS_09>(args_09),
                   std::forward<t_ARGS_10>(args_10))
    {
    }
 
#else
 
    variant();
 
    variant(const variant& original);
 
    variant(BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(const t_TYPE&                                              value,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     const t_ARG_03&                                   arg_03,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::in_place_index_t<t_INDEX>, const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
    variant(bsl::allocator_arg_t, allocator_type allocator);
 
    variant(bsl::allocator_arg_t,
            allocator_type       allocator,
            const variant&       original);
    variant(bsl::allocator_arg_t,
            allocator_type                          allocator,
            BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          const t_TYPE&                                              value,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   const t_ARG_03&                                   arg_03,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
#endif
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06,
                                                t_ARGS_07,
                                                t_ARGS_08,
                                                t_ARGS_09,
                                                t_ARGS_10>::value> >
    t_TYPE& emplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10));
 
        return bsl::get<index>(*this);
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10>::value> >
    t_TYPE& emplace(std::initializer_list<INIT_LIST_TYPE> il,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            il, BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10));
 
        return bsl::get<index>(*this);
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 10u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10>::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10> >::type&
    emplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10));
 
        return bsl::get<t_INDEX>(*this);
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 10u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10>::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10> >::type&
    emplace(std::initializer_list<INIT_LIST_TYPE> il,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            il, BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10));
 
        return bsl::get<t_INDEX>(*this);
    }
 
#else
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace();
 
    template <class t_TYPE, class t_ARG_01>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
 
    template <size_t t_INDEX>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10> >::type&
    emplace();
 
    template <size_t t_INDEX, class t_ARG_01>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10> >::type&
    emplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10> >::type&
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
#endif
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    variant& operator=(const variant& rhs) = default;
 
    variant& operator=(variant&& rhs) = default;
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) value)
    {
        const size_t altIndex =
            BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
        if (index() == altIndex) {
            bsl::get<altIndex>(*this) = BSLS_COMPILERFEATURES_FORWARD(t_TYPE,
                                        value);
        }
        else {
            Variant_Base::template baseEmplace<altIndex>(
                BSLS_COMPILERFEATURES_FORWARD(t_TYPE, value));
        }
 
        return *this;
    }
#else
    variant& operator=(const variant& rhs);
 
    variant& operator=(BloombergLP::bslmf::MovableRef<variant> rhs);
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(const t_TYPE& value);
 
#endif
 
    void swap(variant& other);
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <bool t_USES_BSLMA_ALLOC = BloombergLP::bslstl::
                  Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09,
                                                        t_TAIL_10>::value,
              class = typename bsl::enable_if_t<t_USES_BSLMA_ALLOC> >
#endif
    allocator_type get_allocator() const BSLS_KEYWORD_NOEXCEPT
    {
        return allocator_type(Variant_Base::AllocBase::mechanism());
    }
 
 
    size_t index() const BSLS_KEYWORD_NOEXCEPT;
 
    bool valueless_by_exception() const BSLS_KEYWORD_NOEXCEPT;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
class variant<t_HEAD, t_TAIL_01,
                      t_TAIL_02,
                      t_TAIL_03,
                      t_TAIL_04,
                      t_TAIL_05,
                      t_TAIL_06,
                      t_TAIL_07,
                      t_TAIL_08,
                      t_TAIL_09,
                      t_TAIL_10,
                      t_TAIL_11>
: private BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06,
                                                    t_TAIL_07,
                                                    t_TAIL_08,
                                                    t_TAIL_09,
                                                    t_TAIL_10,
                                                    t_TAIL_11>
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
,
  private BloombergLP::bslstl::Variant_SMFBase<
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11>::value,
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11>::value &&
          BloombergLP::bslstl::Variant_IsCopyAssignableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11>::value &&
          BloombergLP::bslstl::Variant_IsMoveAssignableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11>::value>
#endif
{
  private:
    typedef BloombergLP::bslmf::MovableRefUtil                   MoveUtil;
    typedef BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11> Variant_Base;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11>
        Variant_Union;
 
    friend struct BloombergLP::bslstl::Variant_ImpUtil;
 
    friend struct BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                            t_TAIL_02,
                                                            t_TAIL_03,
                                                            t_TAIL_04,
                                                            t_TAIL_05,
                                                            t_TAIL_06,
                                                            t_TAIL_07,
                                                            t_TAIL_08,
                                                            t_TAIL_09,
                                                            t_TAIL_10,
                                                            t_TAIL_11>;
 
  public:
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11>::value));
 
 
    typedef typename Variant_Base::allocator_type allocator_type;
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_FIRST_ALT = t_HEAD,
              class             = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST_ALT>::value> >
    variant()
    : Variant_Base()
    {
    }
 
    variant(const variant& original) = default;
 
    variant(variant&& original) = default;
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  BSLS_COMPILERFEATURES_FORWARD_REF(t_STD_VARIANT) original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) t,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06,
                                                t_ARGS_07,
                                                t_ARGS_08,
                                                t_ARGS_09,
                                                t_ARGS_10,
                                                t_ARGS_11>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11))
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il,
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11))
    {
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 11u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11>::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11))
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 11u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11>::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   il,
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11))
    {
    }
 
    template <class FIRST = t_HEAD,
              class       = typename bsl::enable_if_t<
                  std::is_default_constructible<FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }
 
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<FIRST, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11>::value> >
    variant(bsl::allocator_arg_t,
            allocator_type allocator,
            const variant& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, original)
    {
    }
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<FIRST, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator, variant&& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, std::move(original))
    {
    }
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  bsl::allocator_arg_t,
                  allocator_type  allocator,
                  BSLS_COMPILERFEATURES_FORWARD_REF(t_STD_VARIANT) original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(bsl::allocator_arg_t(),
                   allocator,
                   BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) t,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06,
                                                t_ARGS_07,
                                                t_ARGS_08,
                                                t_ARGS_09,
                                                t_ARGS_10,
                                                t_ARGS_11>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11)
    : Variant_Base(
          bsl::allocator_arg_t{}
,
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          std::forward<t_ARGS_01>(args_01),
          std::forward<t_ARGS_02>(args_02),
          std::forward<t_ARGS_03>(args_03),
          std::forward<t_ARGS_04>(args_04),
          std::forward<t_ARGS_05>(args_05),
          std::forward<t_ARGS_06>(args_06),
          std::forward<t_ARGS_07>(args_07),
          std::forward<t_ARGS_08>(args_08),
          std::forward<t_ARGS_09>(args_09),
          std::forward<t_ARGS_10>(args_10),
          std::forward<t_ARGS_11>(args_11))
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11)
    : Variant_Base(
          bsl::allocator_arg_t{}
,
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il,
          std::forward<t_ARGS_01>(args_01),
          std::forward<t_ARGS_02>(args_02),
          std::forward<t_ARGS_03>(args_03),
          std::forward<t_ARGS_04>(args_04),
          std::forward<t_ARGS_05>(args_05),
          std::forward<t_ARGS_06>(args_06),
          std::forward<t_ARGS_07>(args_07),
          std::forward<t_ARGS_08>(args_08),
          std::forward<t_ARGS_09>(args_09),
          std::forward<t_ARGS_10>(args_10),
          std::forward<t_ARGS_11>(args_11))
    {
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 11u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11)
    : Variant_Base(bsl::allocator_arg_t{}
,
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   std::forward<t_ARGS_01>(args_01),
                   std::forward<t_ARGS_02>(args_02),
                   std::forward<t_ARGS_03>(args_03),
                   std::forward<t_ARGS_04>(args_04),
                   std::forward<t_ARGS_05>(args_05),
                   std::forward<t_ARGS_06>(args_06),
                   std::forward<t_ARGS_07>(args_07),
                   std::forward<t_ARGS_08>(args_08),
                   std::forward<t_ARGS_09>(args_09),
                   std::forward<t_ARGS_10>(args_10),
                   std::forward<t_ARGS_11>(args_11))
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 11u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11)
    : Variant_Base(bsl::allocator_arg_t{}
,
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   il,
                   std::forward<t_ARGS_01>(args_01),
                   std::forward<t_ARGS_02>(args_02),
                   std::forward<t_ARGS_03>(args_03),
                   std::forward<t_ARGS_04>(args_04),
                   std::forward<t_ARGS_05>(args_05),
                   std::forward<t_ARGS_06>(args_06),
                   std::forward<t_ARGS_07>(args_07),
                   std::forward<t_ARGS_08>(args_08),
                   std::forward<t_ARGS_09>(args_09),
                   std::forward<t_ARGS_10>(args_10),
                   std::forward<t_ARGS_11>(args_11))
    {
    }
 
#else
 
    variant();
 
    variant(const variant& original);
 
    variant(BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(const t_TYPE&                                              value,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     const t_ARG_03&                                   arg_03,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::in_place_index_t<t_INDEX>, const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
    variant(bsl::allocator_arg_t, allocator_type allocator);
 
    variant(bsl::allocator_arg_t,
            allocator_type       allocator,
            const variant&       original);
    variant(bsl::allocator_arg_t,
            allocator_type                          allocator,
            BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          const t_TYPE&                                              value,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   const t_ARG_03&                                   arg_03,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
#endif
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06,
                                                t_ARGS_07,
                                                t_ARGS_08,
                                                t_ARGS_09,
                                                t_ARGS_10,
                                                t_ARGS_11>::value> >
    t_TYPE& emplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11));
 
        return bsl::get<index>(*this);
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11>::value> >
    t_TYPE& emplace(std::initializer_list<INIT_LIST_TYPE> il,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            il, BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11));
 
        return bsl::get<index>(*this);
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 11u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11>::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11> >::type&
    emplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11));
 
        return bsl::get<t_INDEX>(*this);
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 11u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11>::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11> >::type&
    emplace(std::initializer_list<INIT_LIST_TYPE> il,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            il, BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11));
 
        return bsl::get<t_INDEX>(*this);
    }
 
#else
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace();
 
    template <class t_TYPE, class t_ARG_01>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
 
    template <size_t t_INDEX>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11> >::type&
    emplace();
 
    template <size_t t_INDEX, class t_ARG_01>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11> >::type&
    emplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11> >::type&
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
#endif
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    variant& operator=(const variant& rhs) = default;
 
    variant& operator=(variant&& rhs) = default;
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) value)
    {
        const size_t altIndex =
            BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
        if (index() == altIndex) {
            bsl::get<altIndex>(*this) = BSLS_COMPILERFEATURES_FORWARD(t_TYPE,
                                        value);
        }
        else {
            Variant_Base::template baseEmplace<altIndex>(
                BSLS_COMPILERFEATURES_FORWARD(t_TYPE, value));
        }
 
        return *this;
    }
#else
    variant& operator=(const variant& rhs);
 
    variant& operator=(BloombergLP::bslmf::MovableRef<variant> rhs);
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(const t_TYPE& value);
 
#endif
 
    void swap(variant& other);
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <bool t_USES_BSLMA_ALLOC = BloombergLP::bslstl::
                  Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09,
                                                        t_TAIL_10,
                                                        t_TAIL_11>::value,
              class = typename bsl::enable_if_t<t_USES_BSLMA_ALLOC> >
#endif
    allocator_type get_allocator() const BSLS_KEYWORD_NOEXCEPT
    {
        return allocator_type(Variant_Base::AllocBase::mechanism());
    }
 
 
    size_t index() const BSLS_KEYWORD_NOEXCEPT;
 
    bool valueless_by_exception() const BSLS_KEYWORD_NOEXCEPT;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
class variant<t_HEAD, t_TAIL_01,
                      t_TAIL_02,
                      t_TAIL_03,
                      t_TAIL_04,
                      t_TAIL_05,
                      t_TAIL_06,
                      t_TAIL_07,
                      t_TAIL_08,
                      t_TAIL_09,
                      t_TAIL_10,
                      t_TAIL_11,
                      t_TAIL_12>
: private BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06,
                                                    t_TAIL_07,
                                                    t_TAIL_08,
                                                    t_TAIL_09,
                                                    t_TAIL_10,
                                                    t_TAIL_11,
                                                    t_TAIL_12>
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
,
  private BloombergLP::bslstl::Variant_SMFBase<
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12>::value,
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12>::value &&
          BloombergLP::bslstl::Variant_IsCopyAssignableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12>::value &&
          BloombergLP::bslstl::Variant_IsMoveAssignableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12>::value>
#endif
{
  private:
    typedef BloombergLP::bslmf::MovableRefUtil                   MoveUtil;
    typedef BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12> Variant_Base;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11,
                                                       t_TAIL_12>
        Variant_Union;
 
    friend struct BloombergLP::bslstl::Variant_ImpUtil;
 
    friend struct BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                            t_TAIL_02,
                                                            t_TAIL_03,
                                                            t_TAIL_04,
                                                            t_TAIL_05,
                                                            t_TAIL_06,
                                                            t_TAIL_07,
                                                            t_TAIL_08,
                                                            t_TAIL_09,
                                                            t_TAIL_10,
                                                            t_TAIL_11,
                                                            t_TAIL_12>;
 
  public:
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11,
                                                   t_TAIL_12>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11,
                                                   t_TAIL_12>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12>::value));
 
 
    typedef typename Variant_Base::allocator_type allocator_type;
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_FIRST_ALT = t_HEAD,
              class             = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST_ALT>::value> >
    variant()
    : Variant_Base()
    {
    }
 
    variant(const variant& original) = default;
 
    variant(variant&& original) = default;
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  BSLS_COMPILERFEATURES_FORWARD_REF(t_STD_VARIANT) original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) t,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06,
                                                t_ARGS_07,
                                                t_ARGS_08,
                                                t_ARGS_09,
                                                t_ARGS_10,
                                                t_ARGS_11,
                                                t_ARGS_12>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12))
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il,
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12))
    {
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 12u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12>::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12))
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 12u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12>::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   il,
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12))
    {
    }
 
    template <class FIRST = t_HEAD,
              class       = typename bsl::enable_if_t<
                  std::is_default_constructible<FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }
 
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<FIRST, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12>::value> >
    variant(bsl::allocator_arg_t,
            allocator_type allocator,
            const variant& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, original)
    {
    }
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<FIRST, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator, variant&& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, std::move(original))
    {
    }
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  bsl::allocator_arg_t,
                  allocator_type  allocator,
                  BSLS_COMPILERFEATURES_FORWARD_REF(t_STD_VARIANT) original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(bsl::allocator_arg_t(),
                   allocator,
                   BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) t,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06,
                                                t_ARGS_07,
                                                t_ARGS_08,
                                                t_ARGS_09,
                                                t_ARGS_10,
                                                t_ARGS_11,
                                                t_ARGS_12>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12)
    : Variant_Base(
          bsl::allocator_arg_t{}
,
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          std::forward<t_ARGS_01>(args_01),
          std::forward<t_ARGS_02>(args_02),
          std::forward<t_ARGS_03>(args_03),
          std::forward<t_ARGS_04>(args_04),
          std::forward<t_ARGS_05>(args_05),
          std::forward<t_ARGS_06>(args_06),
          std::forward<t_ARGS_07>(args_07),
          std::forward<t_ARGS_08>(args_08),
          std::forward<t_ARGS_09>(args_09),
          std::forward<t_ARGS_10>(args_10),
          std::forward<t_ARGS_11>(args_11),
          std::forward<t_ARGS_12>(args_12))
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12)
    : Variant_Base(
          bsl::allocator_arg_t{}
,
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il,
          std::forward<t_ARGS_01>(args_01),
          std::forward<t_ARGS_02>(args_02),
          std::forward<t_ARGS_03>(args_03),
          std::forward<t_ARGS_04>(args_04),
          std::forward<t_ARGS_05>(args_05),
          std::forward<t_ARGS_06>(args_06),
          std::forward<t_ARGS_07>(args_07),
          std::forward<t_ARGS_08>(args_08),
          std::forward<t_ARGS_09>(args_09),
          std::forward<t_ARGS_10>(args_10),
          std::forward<t_ARGS_11>(args_11),
          std::forward<t_ARGS_12>(args_12))
    {
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 12u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12)
    : Variant_Base(bsl::allocator_arg_t{}
,
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   std::forward<t_ARGS_01>(args_01),
                   std::forward<t_ARGS_02>(args_02),
                   std::forward<t_ARGS_03>(args_03),
                   std::forward<t_ARGS_04>(args_04),
                   std::forward<t_ARGS_05>(args_05),
                   std::forward<t_ARGS_06>(args_06),
                   std::forward<t_ARGS_07>(args_07),
                   std::forward<t_ARGS_08>(args_08),
                   std::forward<t_ARGS_09>(args_09),
                   std::forward<t_ARGS_10>(args_10),
                   std::forward<t_ARGS_11>(args_11),
                   std::forward<t_ARGS_12>(args_12))
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 12u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12)
    : Variant_Base(bsl::allocator_arg_t{}
,
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   il,
                   std::forward<t_ARGS_01>(args_01),
                   std::forward<t_ARGS_02>(args_02),
                   std::forward<t_ARGS_03>(args_03),
                   std::forward<t_ARGS_04>(args_04),
                   std::forward<t_ARGS_05>(args_05),
                   std::forward<t_ARGS_06>(args_06),
                   std::forward<t_ARGS_07>(args_07),
                   std::forward<t_ARGS_08>(args_08),
                   std::forward<t_ARGS_09>(args_09),
                   std::forward<t_ARGS_10>(args_10),
                   std::forward<t_ARGS_11>(args_11),
                   std::forward<t_ARGS_12>(args_12))
    {
    }
 
#else
 
    variant();
 
    variant(const variant& original);
 
    variant(BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(const t_TYPE&                                              value,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     const t_ARG_03&                                   arg_03,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::in_place_index_t<t_INDEX>, const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
    variant(bsl::allocator_arg_t, allocator_type allocator);
 
    variant(bsl::allocator_arg_t,
            allocator_type       allocator,
            const variant&       original);
    variant(bsl::allocator_arg_t,
            allocator_type                          allocator,
            BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          const t_TYPE&                                              value,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   const t_ARG_03&                                   arg_03,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
#endif
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06,
                                                t_ARGS_07,
                                                t_ARGS_08,
                                                t_ARGS_09,
                                                t_ARGS_10,
                                                t_ARGS_11,
                                                t_ARGS_12>::value> >
    t_TYPE& emplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12));
 
        return bsl::get<index>(*this);
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12>::value> >
    t_TYPE& emplace(std::initializer_list<INIT_LIST_TYPE> il,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            il, BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12));
 
        return bsl::get<index>(*this);
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 12u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12>::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12> >::type&
    emplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12));
 
        return bsl::get<t_INDEX>(*this);
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 12u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12>::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12> >::type&
    emplace(std::initializer_list<INIT_LIST_TYPE> il,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            il, BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12));
 
        return bsl::get<t_INDEX>(*this);
    }
 
#else
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace();
 
    template <class t_TYPE, class t_ARG_01>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
 
    template <size_t t_INDEX>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12> >::type&
    emplace();
 
    template <size_t t_INDEX, class t_ARG_01>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12> >::type&
    emplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12> >::type&
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
#endif
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    variant& operator=(const variant& rhs) = default;
 
    variant& operator=(variant&& rhs) = default;
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) value)
    {
        const size_t altIndex =
            BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
        if (index() == altIndex) {
            bsl::get<altIndex>(*this) = BSLS_COMPILERFEATURES_FORWARD(t_TYPE,
                                        value);
        }
        else {
            Variant_Base::template baseEmplace<altIndex>(
                BSLS_COMPILERFEATURES_FORWARD(t_TYPE, value));
        }
 
        return *this;
    }
#else
    variant& operator=(const variant& rhs);
 
    variant& operator=(BloombergLP::bslmf::MovableRef<variant> rhs);
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(const t_TYPE& value);
 
#endif
 
    void swap(variant& other);
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <bool t_USES_BSLMA_ALLOC = BloombergLP::bslstl::
                  Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09,
                                                        t_TAIL_10,
                                                        t_TAIL_11,
                                                        t_TAIL_12>::value,
              class = typename bsl::enable_if_t<t_USES_BSLMA_ALLOC> >
#endif
    allocator_type get_allocator() const BSLS_KEYWORD_NOEXCEPT
    {
        return allocator_type(Variant_Base::AllocBase::mechanism());
    }
 
 
    size_t index() const BSLS_KEYWORD_NOEXCEPT;
 
    bool valueless_by_exception() const BSLS_KEYWORD_NOEXCEPT;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
class variant<t_HEAD, t_TAIL_01,
                      t_TAIL_02,
                      t_TAIL_03,
                      t_TAIL_04,
                      t_TAIL_05,
                      t_TAIL_06,
                      t_TAIL_07,
                      t_TAIL_08,
                      t_TAIL_09,
                      t_TAIL_10,
                      t_TAIL_11,
                      t_TAIL_12,
                      t_TAIL_13>
: private BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06,
                                                    t_TAIL_07,
                                                    t_TAIL_08,
                                                    t_TAIL_09,
                                                    t_TAIL_10,
                                                    t_TAIL_11,
                                                    t_TAIL_12,
                                                    t_TAIL_13>
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
,
  private BloombergLP::bslstl::Variant_SMFBase<
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13>::value,
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13>::value &&
          BloombergLP::bslstl::Variant_IsCopyAssignableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13>::value &&
          BloombergLP::bslstl::Variant_IsMoveAssignableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13>::value>
#endif
{
  private:
    typedef BloombergLP::bslmf::MovableRefUtil                   MoveUtil;
    typedef BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13> Variant_Base;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11,
                                                       t_TAIL_12,
                                                       t_TAIL_13>
        Variant_Union;
 
    friend struct BloombergLP::bslstl::Variant_ImpUtil;
 
    friend struct BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                            t_TAIL_02,
                                                            t_TAIL_03,
                                                            t_TAIL_04,
                                                            t_TAIL_05,
                                                            t_TAIL_06,
                                                            t_TAIL_07,
                                                            t_TAIL_08,
                                                            t_TAIL_09,
                                                            t_TAIL_10,
                                                            t_TAIL_11,
                                                            t_TAIL_12,
                                                            t_TAIL_13>;
 
  public:
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11,
                                                   t_TAIL_12,
                                                   t_TAIL_13>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11,
                                                   t_TAIL_12,
                                                   t_TAIL_13>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13>::value));
 
 
    typedef typename Variant_Base::allocator_type allocator_type;
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_FIRST_ALT = t_HEAD,
              class             = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST_ALT>::value> >
    variant()
    : Variant_Base()
    {
    }
 
    variant(const variant& original) = default;
 
    variant(variant&& original) = default;
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  BSLS_COMPILERFEATURES_FORWARD_REF(t_STD_VARIANT) original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) t,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06,
                                                t_ARGS_07,
                                                t_ARGS_08,
                                                t_ARGS_09,
                                                t_ARGS_10,
                                                t_ARGS_11,
                                                t_ARGS_12,
                                                t_ARGS_13>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13))
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il,
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13))
    {
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 13u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13>::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13))
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 13u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13>::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   il,
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13))
    {
    }
 
    template <class FIRST = t_HEAD,
              class       = typename bsl::enable_if_t<
                  std::is_default_constructible<FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }
 
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<FIRST, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13>::value> >
    variant(bsl::allocator_arg_t,
            allocator_type allocator,
            const variant& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, original)
    {
    }
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<FIRST, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator, variant&& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, std::move(original))
    {
    }
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  bsl::allocator_arg_t,
                  allocator_type  allocator,
                  BSLS_COMPILERFEATURES_FORWARD_REF(t_STD_VARIANT) original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(bsl::allocator_arg_t(),
                   allocator,
                   BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) t,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06,
                                                t_ARGS_07,
                                                t_ARGS_08,
                                                t_ARGS_09,
                                                t_ARGS_10,
                                                t_ARGS_11,
                                                t_ARGS_12,
                                                t_ARGS_13>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13)
    : Variant_Base(
          bsl::allocator_arg_t{}
,
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          std::forward<t_ARGS_01>(args_01),
          std::forward<t_ARGS_02>(args_02),
          std::forward<t_ARGS_03>(args_03),
          std::forward<t_ARGS_04>(args_04),
          std::forward<t_ARGS_05>(args_05),
          std::forward<t_ARGS_06>(args_06),
          std::forward<t_ARGS_07>(args_07),
          std::forward<t_ARGS_08>(args_08),
          std::forward<t_ARGS_09>(args_09),
          std::forward<t_ARGS_10>(args_10),
          std::forward<t_ARGS_11>(args_11),
          std::forward<t_ARGS_12>(args_12),
          std::forward<t_ARGS_13>(args_13))
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13)
    : Variant_Base(
          bsl::allocator_arg_t{}
,
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il,
          std::forward<t_ARGS_01>(args_01),
          std::forward<t_ARGS_02>(args_02),
          std::forward<t_ARGS_03>(args_03),
          std::forward<t_ARGS_04>(args_04),
          std::forward<t_ARGS_05>(args_05),
          std::forward<t_ARGS_06>(args_06),
          std::forward<t_ARGS_07>(args_07),
          std::forward<t_ARGS_08>(args_08),
          std::forward<t_ARGS_09>(args_09),
          std::forward<t_ARGS_10>(args_10),
          std::forward<t_ARGS_11>(args_11),
          std::forward<t_ARGS_12>(args_12),
          std::forward<t_ARGS_13>(args_13))
    {
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 13u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13)
    : Variant_Base(bsl::allocator_arg_t{}
,
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   std::forward<t_ARGS_01>(args_01),
                   std::forward<t_ARGS_02>(args_02),
                   std::forward<t_ARGS_03>(args_03),
                   std::forward<t_ARGS_04>(args_04),
                   std::forward<t_ARGS_05>(args_05),
                   std::forward<t_ARGS_06>(args_06),
                   std::forward<t_ARGS_07>(args_07),
                   std::forward<t_ARGS_08>(args_08),
                   std::forward<t_ARGS_09>(args_09),
                   std::forward<t_ARGS_10>(args_10),
                   std::forward<t_ARGS_11>(args_11),
                   std::forward<t_ARGS_12>(args_12),
                   std::forward<t_ARGS_13>(args_13))
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 13u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13)
    : Variant_Base(bsl::allocator_arg_t{}
,
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   il,
                   std::forward<t_ARGS_01>(args_01),
                   std::forward<t_ARGS_02>(args_02),
                   std::forward<t_ARGS_03>(args_03),
                   std::forward<t_ARGS_04>(args_04),
                   std::forward<t_ARGS_05>(args_05),
                   std::forward<t_ARGS_06>(args_06),
                   std::forward<t_ARGS_07>(args_07),
                   std::forward<t_ARGS_08>(args_08),
                   std::forward<t_ARGS_09>(args_09),
                   std::forward<t_ARGS_10>(args_10),
                   std::forward<t_ARGS_11>(args_11),
                   std::forward<t_ARGS_12>(args_12),
                   std::forward<t_ARGS_13>(args_13))
    {
    }
 
#else
 
    variant();
 
    variant(const variant& original);
 
    variant(BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(const t_TYPE&                                              value,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     const t_ARG_03&                                   arg_03,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::in_place_index_t<t_INDEX>, const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
    variant(bsl::allocator_arg_t, allocator_type allocator);
 
    variant(bsl::allocator_arg_t,
            allocator_type       allocator,
            const variant&       original);
    variant(bsl::allocator_arg_t,
            allocator_type                          allocator,
            BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          const t_TYPE&                                              value,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   const t_ARG_03&                                   arg_03,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
#endif
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06,
                                                t_ARGS_07,
                                                t_ARGS_08,
                                                t_ARGS_09,
                                                t_ARGS_10,
                                                t_ARGS_11,
                                                t_ARGS_12,
                                                t_ARGS_13>::value> >
    t_TYPE& emplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13));
 
        return bsl::get<index>(*this);
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13>::value> >
    t_TYPE& emplace(std::initializer_list<INIT_LIST_TYPE> il,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            il, BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13));
 
        return bsl::get<index>(*this);
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 13u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13>::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13> >::type&
    emplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13));
 
        return bsl::get<t_INDEX>(*this);
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 13u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13>::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13> >::type&
    emplace(std::initializer_list<INIT_LIST_TYPE> il,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            il, BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13));
 
        return bsl::get<t_INDEX>(*this);
    }
 
#else
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace();
 
    template <class t_TYPE, class t_ARG_01>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
 
    template <size_t t_INDEX>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13> >::type&
    emplace();
 
    template <size_t t_INDEX, class t_ARG_01>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13> >::type&
    emplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13> >::type&
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
#endif
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    variant& operator=(const variant& rhs) = default;
 
    variant& operator=(variant&& rhs) = default;
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) value)
    {
        const size_t altIndex =
            BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
        if (index() == altIndex) {
            bsl::get<altIndex>(*this) = BSLS_COMPILERFEATURES_FORWARD(t_TYPE,
                                        value);
        }
        else {
            Variant_Base::template baseEmplace<altIndex>(
                BSLS_COMPILERFEATURES_FORWARD(t_TYPE, value));
        }
 
        return *this;
    }
#else
    variant& operator=(const variant& rhs);
 
    variant& operator=(BloombergLP::bslmf::MovableRef<variant> rhs);
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(const t_TYPE& value);
 
#endif
 
    void swap(variant& other);
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <bool t_USES_BSLMA_ALLOC = BloombergLP::bslstl::
                  Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09,
                                                        t_TAIL_10,
                                                        t_TAIL_11,
                                                        t_TAIL_12,
                                                        t_TAIL_13>::value,
              class = typename bsl::enable_if_t<t_USES_BSLMA_ALLOC> >
#endif
    allocator_type get_allocator() const BSLS_KEYWORD_NOEXCEPT
    {
        return allocator_type(Variant_Base::AllocBase::mechanism());
    }
 
 
    size_t index() const BSLS_KEYWORD_NOEXCEPT;
 
    bool valueless_by_exception() const BSLS_KEYWORD_NOEXCEPT;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
class variant<t_HEAD, t_TAIL_01,
                      t_TAIL_02,
                      t_TAIL_03,
                      t_TAIL_04,
                      t_TAIL_05,
                      t_TAIL_06,
                      t_TAIL_07,
                      t_TAIL_08,
                      t_TAIL_09,
                      t_TAIL_10,
                      t_TAIL_11,
                      t_TAIL_12,
                      t_TAIL_13,
                      t_TAIL_14>
: private BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06,
                                                    t_TAIL_07,
                                                    t_TAIL_08,
                                                    t_TAIL_09,
                                                    t_TAIL_10,
                                                    t_TAIL_11,
                                                    t_TAIL_12,
                                                    t_TAIL_13,
                                                    t_TAIL_14>
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
,
  private BloombergLP::bslstl::Variant_SMFBase<
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14>::value,
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14>::value &&
          BloombergLP::bslstl::Variant_IsCopyAssignableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14>::value &&
          BloombergLP::bslstl::Variant_IsMoveAssignableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14>::value>
#endif
{
  private:
    typedef BloombergLP::bslmf::MovableRefUtil                   MoveUtil;
    typedef BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14> Variant_Base;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11,
                                                       t_TAIL_12,
                                                       t_TAIL_13,
                                                       t_TAIL_14>
        Variant_Union;
 
    friend struct BloombergLP::bslstl::Variant_ImpUtil;
 
    friend struct BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                            t_TAIL_02,
                                                            t_TAIL_03,
                                                            t_TAIL_04,
                                                            t_TAIL_05,
                                                            t_TAIL_06,
                                                            t_TAIL_07,
                                                            t_TAIL_08,
                                                            t_TAIL_09,
                                                            t_TAIL_10,
                                                            t_TAIL_11,
                                                            t_TAIL_12,
                                                            t_TAIL_13,
                                                            t_TAIL_14>;
 
  public:
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11,
                                                   t_TAIL_12,
                                                   t_TAIL_13,
                                                   t_TAIL_14>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11,
                                                   t_TAIL_12,
                                                   t_TAIL_13,
                                                   t_TAIL_14>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14>::value));
 
 
    typedef typename Variant_Base::allocator_type allocator_type;
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_FIRST_ALT = t_HEAD,
              class             = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST_ALT>::value> >
    variant()
    : Variant_Base()
    {
    }
 
    variant(const variant& original) = default;
 
    variant(variant&& original) = default;
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  BSLS_COMPILERFEATURES_FORWARD_REF(t_STD_VARIANT) original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) t,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06,
                                                t_ARGS_07,
                                                t_ARGS_08,
                                                t_ARGS_09,
                                                t_ARGS_10,
                                                t_ARGS_11,
                                                t_ARGS_12,
                                                t_ARGS_13,
                                                t_ARGS_14>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14))
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il,
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14))
    {
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 14u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14>::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14))
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 14u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14>::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   il,
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14))
    {
    }
 
    template <class FIRST = t_HEAD,
              class       = typename bsl::enable_if_t<
                  std::is_default_constructible<FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }
 
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<FIRST, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14>::value> >
    variant(bsl::allocator_arg_t,
            allocator_type allocator,
            const variant& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, original)
    {
    }
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<FIRST, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator, variant&& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, std::move(original))
    {
    }
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  bsl::allocator_arg_t,
                  allocator_type  allocator,
                  BSLS_COMPILERFEATURES_FORWARD_REF(t_STD_VARIANT) original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(bsl::allocator_arg_t(),
                   allocator,
                   BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) t,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06,
                                                t_ARGS_07,
                                                t_ARGS_08,
                                                t_ARGS_09,
                                                t_ARGS_10,
                                                t_ARGS_11,
                                                t_ARGS_12,
                                                t_ARGS_13,
                                                t_ARGS_14>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14)
    : Variant_Base(
          bsl::allocator_arg_t{}
,
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          std::forward<t_ARGS_01>(args_01),
          std::forward<t_ARGS_02>(args_02),
          std::forward<t_ARGS_03>(args_03),
          std::forward<t_ARGS_04>(args_04),
          std::forward<t_ARGS_05>(args_05),
          std::forward<t_ARGS_06>(args_06),
          std::forward<t_ARGS_07>(args_07),
          std::forward<t_ARGS_08>(args_08),
          std::forward<t_ARGS_09>(args_09),
          std::forward<t_ARGS_10>(args_10),
          std::forward<t_ARGS_11>(args_11),
          std::forward<t_ARGS_12>(args_12),
          std::forward<t_ARGS_13>(args_13),
          std::forward<t_ARGS_14>(args_14))
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14)
    : Variant_Base(
          bsl::allocator_arg_t{}
,
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il,
          std::forward<t_ARGS_01>(args_01),
          std::forward<t_ARGS_02>(args_02),
          std::forward<t_ARGS_03>(args_03),
          std::forward<t_ARGS_04>(args_04),
          std::forward<t_ARGS_05>(args_05),
          std::forward<t_ARGS_06>(args_06),
          std::forward<t_ARGS_07>(args_07),
          std::forward<t_ARGS_08>(args_08),
          std::forward<t_ARGS_09>(args_09),
          std::forward<t_ARGS_10>(args_10),
          std::forward<t_ARGS_11>(args_11),
          std::forward<t_ARGS_12>(args_12),
          std::forward<t_ARGS_13>(args_13),
          std::forward<t_ARGS_14>(args_14))
    {
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 14u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14)
    : Variant_Base(bsl::allocator_arg_t{}
,
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   std::forward<t_ARGS_01>(args_01),
                   std::forward<t_ARGS_02>(args_02),
                   std::forward<t_ARGS_03>(args_03),
                   std::forward<t_ARGS_04>(args_04),
                   std::forward<t_ARGS_05>(args_05),
                   std::forward<t_ARGS_06>(args_06),
                   std::forward<t_ARGS_07>(args_07),
                   std::forward<t_ARGS_08>(args_08),
                   std::forward<t_ARGS_09>(args_09),
                   std::forward<t_ARGS_10>(args_10),
                   std::forward<t_ARGS_11>(args_11),
                   std::forward<t_ARGS_12>(args_12),
                   std::forward<t_ARGS_13>(args_13),
                   std::forward<t_ARGS_14>(args_14))
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 14u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14)
    : Variant_Base(bsl::allocator_arg_t{}
,
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   il,
                   std::forward<t_ARGS_01>(args_01),
                   std::forward<t_ARGS_02>(args_02),
                   std::forward<t_ARGS_03>(args_03),
                   std::forward<t_ARGS_04>(args_04),
                   std::forward<t_ARGS_05>(args_05),
                   std::forward<t_ARGS_06>(args_06),
                   std::forward<t_ARGS_07>(args_07),
                   std::forward<t_ARGS_08>(args_08),
                   std::forward<t_ARGS_09>(args_09),
                   std::forward<t_ARGS_10>(args_10),
                   std::forward<t_ARGS_11>(args_11),
                   std::forward<t_ARGS_12>(args_12),
                   std::forward<t_ARGS_13>(args_13),
                   std::forward<t_ARGS_14>(args_14))
    {
    }
 
#else
 
    variant();
 
    variant(const variant& original);
 
    variant(BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(const t_TYPE&                                              value,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     const t_ARG_03&                                   arg_03,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::in_place_index_t<t_INDEX>, const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
    variant(bsl::allocator_arg_t, allocator_type allocator);
 
    variant(bsl::allocator_arg_t,
            allocator_type       allocator,
            const variant&       original);
    variant(bsl::allocator_arg_t,
            allocator_type                          allocator,
            BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          const t_TYPE&                                              value,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   const t_ARG_03&                                   arg_03,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
#endif
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06,
                                                t_ARGS_07,
                                                t_ARGS_08,
                                                t_ARGS_09,
                                                t_ARGS_10,
                                                t_ARGS_11,
                                                t_ARGS_12,
                                                t_ARGS_13,
                                                t_ARGS_14>::value> >
    t_TYPE& emplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14));
 
        return bsl::get<index>(*this);
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14>::value> >
    t_TYPE& emplace(std::initializer_list<INIT_LIST_TYPE> il,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            il, BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14));
 
        return bsl::get<index>(*this);
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 14u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14>::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14> >::type&
    emplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14));
 
        return bsl::get<t_INDEX>(*this);
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 14u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14>::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14> >::type&
    emplace(std::initializer_list<INIT_LIST_TYPE> il,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            il, BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14));
 
        return bsl::get<t_INDEX>(*this);
    }
 
#else
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace();
 
    template <class t_TYPE, class t_ARG_01>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
 
    template <size_t t_INDEX>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14> >::type&
    emplace();
 
    template <size_t t_INDEX, class t_ARG_01>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14> >::type&
    emplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14> >::type&
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
#endif
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    variant& operator=(const variant& rhs) = default;
 
    variant& operator=(variant&& rhs) = default;
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) value)
    {
        const size_t altIndex =
            BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
        if (index() == altIndex) {
            bsl::get<altIndex>(*this) = BSLS_COMPILERFEATURES_FORWARD(t_TYPE,
                                        value);
        }
        else {
            Variant_Base::template baseEmplace<altIndex>(
                BSLS_COMPILERFEATURES_FORWARD(t_TYPE, value));
        }
 
        return *this;
    }
#else
    variant& operator=(const variant& rhs);
 
    variant& operator=(BloombergLP::bslmf::MovableRef<variant> rhs);
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(const t_TYPE& value);
 
#endif
 
    void swap(variant& other);
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <bool t_USES_BSLMA_ALLOC = BloombergLP::bslstl::
                  Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09,
                                                        t_TAIL_10,
                                                        t_TAIL_11,
                                                        t_TAIL_12,
                                                        t_TAIL_13,
                                                        t_TAIL_14>::value,
              class = typename bsl::enable_if_t<t_USES_BSLMA_ALLOC> >
#endif
    allocator_type get_allocator() const BSLS_KEYWORD_NOEXCEPT
    {
        return allocator_type(Variant_Base::AllocBase::mechanism());
    }
 
 
    size_t index() const BSLS_KEYWORD_NOEXCEPT;
 
    bool valueless_by_exception() const BSLS_KEYWORD_NOEXCEPT;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
class variant<t_HEAD, t_TAIL_01,
                      t_TAIL_02,
                      t_TAIL_03,
                      t_TAIL_04,
                      t_TAIL_05,
                      t_TAIL_06,
                      t_TAIL_07,
                      t_TAIL_08,
                      t_TAIL_09,
                      t_TAIL_10,
                      t_TAIL_11,
                      t_TAIL_12,
                      t_TAIL_13,
                      t_TAIL_14,
                      t_TAIL_15>
: private BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06,
                                                    t_TAIL_07,
                                                    t_TAIL_08,
                                                    t_TAIL_09,
                                                    t_TAIL_10,
                                                    t_TAIL_11,
                                                    t_TAIL_12,
                                                    t_TAIL_13,
                                                    t_TAIL_14,
                                                    t_TAIL_15>
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
,
  private BloombergLP::bslstl::Variant_SMFBase<
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15>::value,
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15>::value &&
          BloombergLP::bslstl::Variant_IsCopyAssignableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14,
                                                           t_TAIL_15>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15>::value &&
          BloombergLP::bslstl::Variant_IsMoveAssignableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14,
                                                           t_TAIL_15>::value>
#endif
{
  private:
    typedef BloombergLP::bslmf::MovableRefUtil                   MoveUtil;
    typedef BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15> Variant_Base;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11,
                                                       t_TAIL_12,
                                                       t_TAIL_13,
                                                       t_TAIL_14,
                                                       t_TAIL_15>
        Variant_Union;
 
    friend struct BloombergLP::bslstl::Variant_ImpUtil;
 
    friend struct BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                            t_TAIL_02,
                                                            t_TAIL_03,
                                                            t_TAIL_04,
                                                            t_TAIL_05,
                                                            t_TAIL_06,
                                                            t_TAIL_07,
                                                            t_TAIL_08,
                                                            t_TAIL_09,
                                                            t_TAIL_10,
                                                            t_TAIL_11,
                                                            t_TAIL_12,
                                                            t_TAIL_13,
                                                            t_TAIL_14,
                                                            t_TAIL_15>;
 
  public:
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11,
                                                   t_TAIL_12,
                                                   t_TAIL_13,
                                                   t_TAIL_14,
                                                   t_TAIL_15>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11,
                                                   t_TAIL_12,
                                                   t_TAIL_13,
                                                   t_TAIL_14,
                                                   t_TAIL_15>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14,
                                                           t_TAIL_15>::value));
 
 
    typedef typename Variant_Base::allocator_type allocator_type;
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_FIRST_ALT = t_HEAD,
              class             = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST_ALT>::value> >
    variant()
    : Variant_Base()
    {
    }
 
    variant(const variant& original) = default;
 
    variant(variant&& original) = default;
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  BSLS_COMPILERFEATURES_FORWARD_REF(t_STD_VARIANT) original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) t,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06,
                                                t_ARGS_07,
                                                t_ARGS_08,
                                                t_ARGS_09,
                                                t_ARGS_10,
                                                t_ARGS_11,
                                                t_ARGS_12,
                                                t_ARGS_13,
                                                t_ARGS_14,
                                                t_ARGS_15>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_15, args_15))
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14,
                                        t_ARGS_15>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il,
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_15, args_15))
    {
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 15u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14,
                                        t_ARGS_15>::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_15, args_15))
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 15u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14,
                                        t_ARGS_15>::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   il,
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_15, args_15))
    {
    }
 
    template <class FIRST = t_HEAD,
              class       = typename bsl::enable_if_t<
                  std::is_default_constructible<FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }
 
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<FIRST, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15>::value> >
    variant(bsl::allocator_arg_t,
            allocator_type allocator,
            const variant& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, original)
    {
    }
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<FIRST, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator, variant&& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, std::move(original))
    {
    }
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  bsl::allocator_arg_t,
                  allocator_type  allocator,
                  BSLS_COMPILERFEATURES_FORWARD_REF(t_STD_VARIANT) original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(bsl::allocator_arg_t(),
                   allocator,
                   BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) t,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06,
                                                t_ARGS_07,
                                                t_ARGS_08,
                                                t_ARGS_09,
                                                t_ARGS_10,
                                                t_ARGS_11,
                                                t_ARGS_12,
                                                t_ARGS_13,
                                                t_ARGS_14,
                                                t_ARGS_15>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15)
    : Variant_Base(
          bsl::allocator_arg_t{}
,
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          std::forward<t_ARGS_01>(args_01),
          std::forward<t_ARGS_02>(args_02),
          std::forward<t_ARGS_03>(args_03),
          std::forward<t_ARGS_04>(args_04),
          std::forward<t_ARGS_05>(args_05),
          std::forward<t_ARGS_06>(args_06),
          std::forward<t_ARGS_07>(args_07),
          std::forward<t_ARGS_08>(args_08),
          std::forward<t_ARGS_09>(args_09),
          std::forward<t_ARGS_10>(args_10),
          std::forward<t_ARGS_11>(args_11),
          std::forward<t_ARGS_12>(args_12),
          std::forward<t_ARGS_13>(args_13),
          std::forward<t_ARGS_14>(args_14),
          std::forward<t_ARGS_15>(args_15))
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14,
                                        t_ARGS_15>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15)
    : Variant_Base(
          bsl::allocator_arg_t{}
,
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il,
          std::forward<t_ARGS_01>(args_01),
          std::forward<t_ARGS_02>(args_02),
          std::forward<t_ARGS_03>(args_03),
          std::forward<t_ARGS_04>(args_04),
          std::forward<t_ARGS_05>(args_05),
          std::forward<t_ARGS_06>(args_06),
          std::forward<t_ARGS_07>(args_07),
          std::forward<t_ARGS_08>(args_08),
          std::forward<t_ARGS_09>(args_09),
          std::forward<t_ARGS_10>(args_10),
          std::forward<t_ARGS_11>(args_11),
          std::forward<t_ARGS_12>(args_12),
          std::forward<t_ARGS_13>(args_13),
          std::forward<t_ARGS_14>(args_14),
          std::forward<t_ARGS_15>(args_15))
    {
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 15u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14,
                                        t_ARGS_15>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15)
    : Variant_Base(bsl::allocator_arg_t{}
,
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   std::forward<t_ARGS_01>(args_01),
                   std::forward<t_ARGS_02>(args_02),
                   std::forward<t_ARGS_03>(args_03),
                   std::forward<t_ARGS_04>(args_04),
                   std::forward<t_ARGS_05>(args_05),
                   std::forward<t_ARGS_06>(args_06),
                   std::forward<t_ARGS_07>(args_07),
                   std::forward<t_ARGS_08>(args_08),
                   std::forward<t_ARGS_09>(args_09),
                   std::forward<t_ARGS_10>(args_10),
                   std::forward<t_ARGS_11>(args_11),
                   std::forward<t_ARGS_12>(args_12),
                   std::forward<t_ARGS_13>(args_13),
                   std::forward<t_ARGS_14>(args_14),
                   std::forward<t_ARGS_15>(args_15))
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 15u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14,
                                        t_ARGS_15>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15)
    : Variant_Base(bsl::allocator_arg_t{}
,
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   il,
                   std::forward<t_ARGS_01>(args_01),
                   std::forward<t_ARGS_02>(args_02),
                   std::forward<t_ARGS_03>(args_03),
                   std::forward<t_ARGS_04>(args_04),
                   std::forward<t_ARGS_05>(args_05),
                   std::forward<t_ARGS_06>(args_06),
                   std::forward<t_ARGS_07>(args_07),
                   std::forward<t_ARGS_08>(args_08),
                   std::forward<t_ARGS_09>(args_09),
                   std::forward<t_ARGS_10>(args_10),
                   std::forward<t_ARGS_11>(args_11),
                   std::forward<t_ARGS_12>(args_12),
                   std::forward<t_ARGS_13>(args_13),
                   std::forward<t_ARGS_14>(args_14),
                   std::forward<t_ARGS_15>(args_15))
    {
    }
 
#else
 
    variant();
 
    variant(const variant& original);
 
    variant(BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(const t_TYPE&                                              value,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     const t_ARG_03&                                   arg_03,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::in_place_index_t<t_INDEX>, const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
    variant(bsl::allocator_arg_t, allocator_type allocator);
 
    variant(bsl::allocator_arg_t,
            allocator_type       allocator,
            const variant&       original);
    variant(bsl::allocator_arg_t,
            allocator_type                          allocator,
            BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          const t_TYPE&                                              value,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   const t_ARG_03&                                   arg_03,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
#endif
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06,
                                                t_ARGS_07,
                                                t_ARGS_08,
                                                t_ARGS_09,
                                                t_ARGS_10,
                                                t_ARGS_11,
                                                t_ARGS_12,
                                                t_ARGS_13,
                                                t_ARGS_14,
                                                t_ARGS_15>::value> >
    t_TYPE& emplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_15, args_15));
 
        return bsl::get<index>(*this);
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14,
                                        t_ARGS_15>::value> >
    t_TYPE& emplace(std::initializer_list<INIT_LIST_TYPE> il,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            il, BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_15, args_15));
 
        return bsl::get<index>(*this);
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 15u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14,
                                        t_ARGS_15>::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15> >::type&
    emplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_15, args_15));
 
        return bsl::get<t_INDEX>(*this);
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 15u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14,
                                        t_ARGS_15>::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15> >::type&
    emplace(std::initializer_list<INIT_LIST_TYPE> il,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            il, BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_15, args_15));
 
        return bsl::get<t_INDEX>(*this);
    }
 
#else
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace();
 
    template <class t_TYPE, class t_ARG_01>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
 
    template <size_t t_INDEX>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15> >::type&
    emplace();
 
    template <size_t t_INDEX, class t_ARG_01>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15> >::type&
    emplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15> >::type&
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
#endif
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    variant& operator=(const variant& rhs) = default;
 
    variant& operator=(variant&& rhs) = default;
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) value)
    {
        const size_t altIndex =
            BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
        if (index() == altIndex) {
            bsl::get<altIndex>(*this) = BSLS_COMPILERFEATURES_FORWARD(t_TYPE,
                                        value);
        }
        else {
            Variant_Base::template baseEmplace<altIndex>(
                BSLS_COMPILERFEATURES_FORWARD(t_TYPE, value));
        }
 
        return *this;
    }
#else
    variant& operator=(const variant& rhs);
 
    variant& operator=(BloombergLP::bslmf::MovableRef<variant> rhs);
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(const t_TYPE& value);
 
#endif
 
    void swap(variant& other);
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <bool t_USES_BSLMA_ALLOC = BloombergLP::bslstl::
                  Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09,
                                                        t_TAIL_10,
                                                        t_TAIL_11,
                                                        t_TAIL_12,
                                                        t_TAIL_13,
                                                        t_TAIL_14,
                                                        t_TAIL_15>::value,
              class = typename bsl::enable_if_t<t_USES_BSLMA_ALLOC> >
#endif
    allocator_type get_allocator() const BSLS_KEYWORD_NOEXCEPT
    {
        return allocator_type(Variant_Base::AllocBase::mechanism());
    }
 
 
    size_t index() const BSLS_KEYWORD_NOEXCEPT;
 
    bool valueless_by_exception() const BSLS_KEYWORD_NOEXCEPT;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
class variant<t_HEAD, t_TAIL_01,
                      t_TAIL_02,
                      t_TAIL_03,
                      t_TAIL_04,
                      t_TAIL_05,
                      t_TAIL_06,
                      t_TAIL_07,
                      t_TAIL_08,
                      t_TAIL_09,
                      t_TAIL_10,
                      t_TAIL_11,
                      t_TAIL_12,
                      t_TAIL_13,
                      t_TAIL_14,
                      t_TAIL_15,
                      t_TAIL_16>
: private BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06,
                                                    t_TAIL_07,
                                                    t_TAIL_08,
                                                    t_TAIL_09,
                                                    t_TAIL_10,
                                                    t_TAIL_11,
                                                    t_TAIL_12,
                                                    t_TAIL_13,
                                                    t_TAIL_14,
                                                    t_TAIL_15,
                                                    t_TAIL_16>
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
,
  private BloombergLP::bslstl::Variant_SMFBase<
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16>::value,
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16>::value &&
          BloombergLP::bslstl::Variant_IsCopyAssignableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14,
                                                           t_TAIL_15,
                                                           t_TAIL_16>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16>::value &&
          BloombergLP::bslstl::Variant_IsMoveAssignableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14,
                                                           t_TAIL_15,
                                                           t_TAIL_16>::value>
#endif
{
  private:
    typedef BloombergLP::bslmf::MovableRefUtil                   MoveUtil;
    typedef BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16> Variant_Base;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11,
                                                       t_TAIL_12,
                                                       t_TAIL_13,
                                                       t_TAIL_14,
                                                       t_TAIL_15,
                                                       t_TAIL_16>
        Variant_Union;
 
    friend struct BloombergLP::bslstl::Variant_ImpUtil;
 
    friend struct BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                            t_TAIL_02,
                                                            t_TAIL_03,
                                                            t_TAIL_04,
                                                            t_TAIL_05,
                                                            t_TAIL_06,
                                                            t_TAIL_07,
                                                            t_TAIL_08,
                                                            t_TAIL_09,
                                                            t_TAIL_10,
                                                            t_TAIL_11,
                                                            t_TAIL_12,
                                                            t_TAIL_13,
                                                            t_TAIL_14,
                                                            t_TAIL_15,
                                                            t_TAIL_16>;
 
  public:
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11,
                                                   t_TAIL_12,
                                                   t_TAIL_13,
                                                   t_TAIL_14,
                                                   t_TAIL_15,
                                                   t_TAIL_16>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11,
                                                   t_TAIL_12,
                                                   t_TAIL_13,
                                                   t_TAIL_14,
                                                   t_TAIL_15,
                                                   t_TAIL_16>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14,
                                                           t_TAIL_15,
                                                           t_TAIL_16>::value));
 
 
    typedef typename Variant_Base::allocator_type allocator_type;
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_FIRST_ALT = t_HEAD,
              class             = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST_ALT>::value> >
    variant()
    : Variant_Base()
    {
    }
 
    variant(const variant& original) = default;
 
    variant(variant&& original) = default;
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  BSLS_COMPILERFEATURES_FORWARD_REF(t_STD_VARIANT) original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) t,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class t_ARGS_16,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06,
                                                t_ARGS_07,
                                                t_ARGS_08,
                                                t_ARGS_09,
                                                t_ARGS_10,
                                                t_ARGS_11,
                                                t_ARGS_12,
                                                t_ARGS_13,
                                                t_ARGS_14,
                                                t_ARGS_15,
                                                t_ARGS_16>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_15, args_15),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_16, args_16))
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class t_ARGS_16,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14,
                                        t_ARGS_15,
                                        t_ARGS_16>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il,
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_15, args_15),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_16, args_16))
    {
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class t_ARGS_16,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 16u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14,
                                        t_ARGS_15,
                                        t_ARGS_16>::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_15, args_15),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_16, args_16))
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class t_ARGS_16,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 16u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14,
                                        t_ARGS_15,
                                        t_ARGS_16>::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   il,
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_15, args_15),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_16, args_16))
    {
    }
 
    template <class FIRST = t_HEAD,
              class       = typename bsl::enable_if_t<
                  std::is_default_constructible<FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }
 
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<FIRST, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16>::value> >
    variant(bsl::allocator_arg_t,
            allocator_type allocator,
            const variant& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, original)
    {
    }
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<FIRST, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator, variant&& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, std::move(original))
    {
    }
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  bsl::allocator_arg_t,
                  allocator_type  allocator,
                  BSLS_COMPILERFEATURES_FORWARD_REF(t_STD_VARIANT) original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(bsl::allocator_arg_t(),
                   allocator,
                   BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) t,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class t_ARGS_16,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06,
                                                t_ARGS_07,
                                                t_ARGS_08,
                                                t_ARGS_09,
                                                t_ARGS_10,
                                                t_ARGS_11,
                                                t_ARGS_12,
                                                t_ARGS_13,
                                                t_ARGS_14,
                                                t_ARGS_15,
                                                t_ARGS_16>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16)
    : Variant_Base(
          bsl::allocator_arg_t{}
,
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          std::forward<t_ARGS_01>(args_01),
          std::forward<t_ARGS_02>(args_02),
          std::forward<t_ARGS_03>(args_03),
          std::forward<t_ARGS_04>(args_04),
          std::forward<t_ARGS_05>(args_05),
          std::forward<t_ARGS_06>(args_06),
          std::forward<t_ARGS_07>(args_07),
          std::forward<t_ARGS_08>(args_08),
          std::forward<t_ARGS_09>(args_09),
          std::forward<t_ARGS_10>(args_10),
          std::forward<t_ARGS_11>(args_11),
          std::forward<t_ARGS_12>(args_12),
          std::forward<t_ARGS_13>(args_13),
          std::forward<t_ARGS_14>(args_14),
          std::forward<t_ARGS_15>(args_15),
          std::forward<t_ARGS_16>(args_16))
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class t_ARGS_16,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14,
                                        t_ARGS_15,
                                        t_ARGS_16>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16)
    : Variant_Base(
          bsl::allocator_arg_t{}
,
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il,
          std::forward<t_ARGS_01>(args_01),
          std::forward<t_ARGS_02>(args_02),
          std::forward<t_ARGS_03>(args_03),
          std::forward<t_ARGS_04>(args_04),
          std::forward<t_ARGS_05>(args_05),
          std::forward<t_ARGS_06>(args_06),
          std::forward<t_ARGS_07>(args_07),
          std::forward<t_ARGS_08>(args_08),
          std::forward<t_ARGS_09>(args_09),
          std::forward<t_ARGS_10>(args_10),
          std::forward<t_ARGS_11>(args_11),
          std::forward<t_ARGS_12>(args_12),
          std::forward<t_ARGS_13>(args_13),
          std::forward<t_ARGS_14>(args_14),
          std::forward<t_ARGS_15>(args_15),
          std::forward<t_ARGS_16>(args_16))
    {
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class t_ARGS_16,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 16u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14,
                                        t_ARGS_15,
                                        t_ARGS_16>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16)
    : Variant_Base(bsl::allocator_arg_t{}
,
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   std::forward<t_ARGS_01>(args_01),
                   std::forward<t_ARGS_02>(args_02),
                   std::forward<t_ARGS_03>(args_03),
                   std::forward<t_ARGS_04>(args_04),
                   std::forward<t_ARGS_05>(args_05),
                   std::forward<t_ARGS_06>(args_06),
                   std::forward<t_ARGS_07>(args_07),
                   std::forward<t_ARGS_08>(args_08),
                   std::forward<t_ARGS_09>(args_09),
                   std::forward<t_ARGS_10>(args_10),
                   std::forward<t_ARGS_11>(args_11),
                   std::forward<t_ARGS_12>(args_12),
                   std::forward<t_ARGS_13>(args_13),
                   std::forward<t_ARGS_14>(args_14),
                   std::forward<t_ARGS_15>(args_15),
                   std::forward<t_ARGS_16>(args_16))
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class t_ARGS_16,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 16u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14,
                                        t_ARGS_15,
                                        t_ARGS_16>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16)
    : Variant_Base(bsl::allocator_arg_t{}
,
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   il,
                   std::forward<t_ARGS_01>(args_01),
                   std::forward<t_ARGS_02>(args_02),
                   std::forward<t_ARGS_03>(args_03),
                   std::forward<t_ARGS_04>(args_04),
                   std::forward<t_ARGS_05>(args_05),
                   std::forward<t_ARGS_06>(args_06),
                   std::forward<t_ARGS_07>(args_07),
                   std::forward<t_ARGS_08>(args_08),
                   std::forward<t_ARGS_09>(args_09),
                   std::forward<t_ARGS_10>(args_10),
                   std::forward<t_ARGS_11>(args_11),
                   std::forward<t_ARGS_12>(args_12),
                   std::forward<t_ARGS_13>(args_13),
                   std::forward<t_ARGS_14>(args_14),
                   std::forward<t_ARGS_15>(args_15),
                   std::forward<t_ARGS_16>(args_16))
    {
    }
 
#else
 
    variant();
 
    variant(const variant& original);
 
    variant(BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(const t_TYPE&                                              value,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     const t_ARG_03&                                   arg_03,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::in_place_index_t<t_INDEX>, const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
    variant(bsl::allocator_arg_t, allocator_type allocator);
 
    variant(bsl::allocator_arg_t,
            allocator_type       allocator,
            const variant&       original);
    variant(bsl::allocator_arg_t,
            allocator_type                          allocator,
            BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          const t_TYPE&                                              value,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   const t_ARG_03&                                   arg_03,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
#endif
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class t_ARGS_16,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06,
                                                t_ARGS_07,
                                                t_ARGS_08,
                                                t_ARGS_09,
                                                t_ARGS_10,
                                                t_ARGS_11,
                                                t_ARGS_12,
                                                t_ARGS_13,
                                                t_ARGS_14,
                                                t_ARGS_15,
                                                t_ARGS_16>::value> >
    t_TYPE& emplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_15, args_15),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_16, args_16));
 
        return bsl::get<index>(*this);
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class t_ARGS_16,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14,
                                        t_ARGS_15,
                                        t_ARGS_16>::value> >
    t_TYPE& emplace(std::initializer_list<INIT_LIST_TYPE> il,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            il, BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_15, args_15),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_16, args_16));
 
        return bsl::get<index>(*this);
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class t_ARGS_16,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 16u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14,
                                        t_ARGS_15,
                                        t_ARGS_16>::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16> >::type&
    emplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_15, args_15),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_16, args_16));
 
        return bsl::get<t_INDEX>(*this);
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class t_ARGS_16,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 16u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14,
                                        t_ARGS_15,
                                        t_ARGS_16>::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16> >::type&
    emplace(std::initializer_list<INIT_LIST_TYPE> il,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            il, BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_15, args_15),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_16, args_16));
 
        return bsl::get<t_INDEX>(*this);
    }
 
#else
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace();
 
    template <class t_TYPE, class t_ARG_01>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
 
    template <size_t t_INDEX>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16> >::type&
    emplace();
 
    template <size_t t_INDEX, class t_ARG_01>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16> >::type&
    emplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16> >::type&
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
#endif
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    variant& operator=(const variant& rhs) = default;
 
    variant& operator=(variant&& rhs) = default;
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) value)
    {
        const size_t altIndex =
            BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
        if (index() == altIndex) {
            bsl::get<altIndex>(*this) = BSLS_COMPILERFEATURES_FORWARD(t_TYPE,
                                        value);
        }
        else {
            Variant_Base::template baseEmplace<altIndex>(
                BSLS_COMPILERFEATURES_FORWARD(t_TYPE, value));
        }
 
        return *this;
    }
#else
    variant& operator=(const variant& rhs);
 
    variant& operator=(BloombergLP::bslmf::MovableRef<variant> rhs);
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(const t_TYPE& value);
 
#endif
 
    void swap(variant& other);
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <bool t_USES_BSLMA_ALLOC = BloombergLP::bslstl::
                  Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09,
                                                        t_TAIL_10,
                                                        t_TAIL_11,
                                                        t_TAIL_12,
                                                        t_TAIL_13,
                                                        t_TAIL_14,
                                                        t_TAIL_15,
                                                        t_TAIL_16>::value,
              class = typename bsl::enable_if_t<t_USES_BSLMA_ALLOC> >
#endif
    allocator_type get_allocator() const BSLS_KEYWORD_NOEXCEPT
    {
        return allocator_type(Variant_Base::AllocBase::mechanism());
    }
 
 
    size_t index() const BSLS_KEYWORD_NOEXCEPT;
 
    bool valueless_by_exception() const BSLS_KEYWORD_NOEXCEPT;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
class variant<t_HEAD, t_TAIL_01,
                      t_TAIL_02,
                      t_TAIL_03,
                      t_TAIL_04,
                      t_TAIL_05,
                      t_TAIL_06,
                      t_TAIL_07,
                      t_TAIL_08,
                      t_TAIL_09,
                      t_TAIL_10,
                      t_TAIL_11,
                      t_TAIL_12,
                      t_TAIL_13,
                      t_TAIL_14,
                      t_TAIL_15,
                      t_TAIL_16,
                      t_TAIL_17>
: private BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06,
                                                    t_TAIL_07,
                                                    t_TAIL_08,
                                                    t_TAIL_09,
                                                    t_TAIL_10,
                                                    t_TAIL_11,
                                                    t_TAIL_12,
                                                    t_TAIL_13,
                                                    t_TAIL_14,
                                                    t_TAIL_15,
                                                    t_TAIL_16,
                                                    t_TAIL_17>
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
,
  private BloombergLP::bslstl::Variant_SMFBase<
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17>::value,
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17>::value &&
          BloombergLP::bslstl::Variant_IsCopyAssignableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14,
                                                           t_TAIL_15,
                                                           t_TAIL_16,
                                                           t_TAIL_17>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17>::value &&
          BloombergLP::bslstl::Variant_IsMoveAssignableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14,
                                                           t_TAIL_15,
                                                           t_TAIL_16,
                                                           t_TAIL_17>::value>
#endif
{
  private:
    typedef BloombergLP::bslmf::MovableRefUtil                   MoveUtil;
    typedef BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16,
                                                      t_TAIL_17> Variant_Base;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11,
                                                       t_TAIL_12,
                                                       t_TAIL_13,
                                                       t_TAIL_14,
                                                       t_TAIL_15,
                                                       t_TAIL_16,
                                                       t_TAIL_17>
        Variant_Union;
 
    friend struct BloombergLP::bslstl::Variant_ImpUtil;
 
    friend struct BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                            t_TAIL_02,
                                                            t_TAIL_03,
                                                            t_TAIL_04,
                                                            t_TAIL_05,
                                                            t_TAIL_06,
                                                            t_TAIL_07,
                                                            t_TAIL_08,
                                                            t_TAIL_09,
                                                            t_TAIL_10,
                                                            t_TAIL_11,
                                                            t_TAIL_12,
                                                            t_TAIL_13,
                                                            t_TAIL_14,
                                                            t_TAIL_15,
                                                            t_TAIL_16,
                                                            t_TAIL_17>;
 
  public:
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11,
                                                   t_TAIL_12,
                                                   t_TAIL_13,
                                                   t_TAIL_14,
                                                   t_TAIL_15,
                                                   t_TAIL_16,
                                                   t_TAIL_17>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11,
                                                   t_TAIL_12,
                                                   t_TAIL_13,
                                                   t_TAIL_14,
                                                   t_TAIL_15,
                                                   t_TAIL_16,
                                                   t_TAIL_17>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14,
                                                           t_TAIL_15,
                                                           t_TAIL_16,
                                                           t_TAIL_17>::value));
 
 
    typedef typename Variant_Base::allocator_type allocator_type;
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_FIRST_ALT = t_HEAD,
              class             = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST_ALT>::value> >
    variant()
    : Variant_Base()
    {
    }
 
    variant(const variant& original) = default;
 
    variant(variant&& original) = default;
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  BSLS_COMPILERFEATURES_FORWARD_REF(t_STD_VARIANT) original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) t,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class t_ARGS_16,
              class t_ARGS_17,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06,
                                                t_ARGS_07,
                                                t_ARGS_08,
                                                t_ARGS_09,
                                                t_ARGS_10,
                                                t_ARGS_11,
                                                t_ARGS_12,
                                                t_ARGS_13,
                                                t_ARGS_14,
                                                t_ARGS_15,
                                                t_ARGS_16,
                                                t_ARGS_17>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_17) args_17)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_15, args_15),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_16, args_16),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_17, args_17))
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class t_ARGS_16,
              class t_ARGS_17,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14,
                                        t_ARGS_15,
                                        t_ARGS_16,
                                        t_ARGS_17>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_17) args_17)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il,
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_15, args_15),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_16, args_16),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_17, args_17))
    {
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class t_ARGS_16,
              class t_ARGS_17,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 17u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14,
                                        t_ARGS_15,
                                        t_ARGS_16,
                                        t_ARGS_17>::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_17) args_17)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_15, args_15),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_16, args_16),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_17, args_17))
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class t_ARGS_16,
              class t_ARGS_17,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 17u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14,
                                        t_ARGS_15,
                                        t_ARGS_16,
                                        t_ARGS_17>::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_17) args_17)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   il,
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_15, args_15),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_16, args_16),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_17, args_17))
    {
    }
 
    template <class FIRST = t_HEAD,
              class       = typename bsl::enable_if_t<
                  std::is_default_constructible<FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }
 
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<FIRST, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16,
                                                      t_TAIL_17>::value> >
    variant(bsl::allocator_arg_t,
            allocator_type allocator,
            const variant& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, original)
    {
    }
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<FIRST, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16,
                                                      t_TAIL_17>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator, variant&& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, std::move(original))
    {
    }
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  bsl::allocator_arg_t,
                  allocator_type  allocator,
                  BSLS_COMPILERFEATURES_FORWARD_REF(t_STD_VARIANT) original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(bsl::allocator_arg_t(),
                   allocator,
                   BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) t,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class t_ARGS_16,
              class t_ARGS_17,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06,
                                                t_ARGS_07,
                                                t_ARGS_08,
                                                t_ARGS_09,
                                                t_ARGS_10,
                                                t_ARGS_11,
                                                t_ARGS_12,
                                                t_ARGS_13,
                                                t_ARGS_14,
                                                t_ARGS_15,
                                                t_ARGS_16,
                                                t_ARGS_17>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_17) args_17)
    : Variant_Base(
          bsl::allocator_arg_t{}
,
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          std::forward<t_ARGS_01>(args_01),
          std::forward<t_ARGS_02>(args_02),
          std::forward<t_ARGS_03>(args_03),
          std::forward<t_ARGS_04>(args_04),
          std::forward<t_ARGS_05>(args_05),
          std::forward<t_ARGS_06>(args_06),
          std::forward<t_ARGS_07>(args_07),
          std::forward<t_ARGS_08>(args_08),
          std::forward<t_ARGS_09>(args_09),
          std::forward<t_ARGS_10>(args_10),
          std::forward<t_ARGS_11>(args_11),
          std::forward<t_ARGS_12>(args_12),
          std::forward<t_ARGS_13>(args_13),
          std::forward<t_ARGS_14>(args_14),
          std::forward<t_ARGS_15>(args_15),
          std::forward<t_ARGS_16>(args_16),
          std::forward<t_ARGS_17>(args_17))
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class t_ARGS_16,
              class t_ARGS_17,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14,
                                        t_ARGS_15,
                                        t_ARGS_16,
                                        t_ARGS_17>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_17) args_17)
    : Variant_Base(
          bsl::allocator_arg_t{}
,
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il,
          std::forward<t_ARGS_01>(args_01),
          std::forward<t_ARGS_02>(args_02),
          std::forward<t_ARGS_03>(args_03),
          std::forward<t_ARGS_04>(args_04),
          std::forward<t_ARGS_05>(args_05),
          std::forward<t_ARGS_06>(args_06),
          std::forward<t_ARGS_07>(args_07),
          std::forward<t_ARGS_08>(args_08),
          std::forward<t_ARGS_09>(args_09),
          std::forward<t_ARGS_10>(args_10),
          std::forward<t_ARGS_11>(args_11),
          std::forward<t_ARGS_12>(args_12),
          std::forward<t_ARGS_13>(args_13),
          std::forward<t_ARGS_14>(args_14),
          std::forward<t_ARGS_15>(args_15),
          std::forward<t_ARGS_16>(args_16),
          std::forward<t_ARGS_17>(args_17))
    {
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class t_ARGS_16,
              class t_ARGS_17,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 17u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14,
                                        t_ARGS_15,
                                        t_ARGS_16,
                                        t_ARGS_17>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_17) args_17)
    : Variant_Base(bsl::allocator_arg_t{}
,
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   std::forward<t_ARGS_01>(args_01),
                   std::forward<t_ARGS_02>(args_02),
                   std::forward<t_ARGS_03>(args_03),
                   std::forward<t_ARGS_04>(args_04),
                   std::forward<t_ARGS_05>(args_05),
                   std::forward<t_ARGS_06>(args_06),
                   std::forward<t_ARGS_07>(args_07),
                   std::forward<t_ARGS_08>(args_08),
                   std::forward<t_ARGS_09>(args_09),
                   std::forward<t_ARGS_10>(args_10),
                   std::forward<t_ARGS_11>(args_11),
                   std::forward<t_ARGS_12>(args_12),
                   std::forward<t_ARGS_13>(args_13),
                   std::forward<t_ARGS_14>(args_14),
                   std::forward<t_ARGS_15>(args_15),
                   std::forward<t_ARGS_16>(args_16),
                   std::forward<t_ARGS_17>(args_17))
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class t_ARGS_16,
              class t_ARGS_17,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 17u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14,
                                        t_ARGS_15,
                                        t_ARGS_16,
                                        t_ARGS_17>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_17) args_17)
    : Variant_Base(bsl::allocator_arg_t{}
,
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   il,
                   std::forward<t_ARGS_01>(args_01),
                   std::forward<t_ARGS_02>(args_02),
                   std::forward<t_ARGS_03>(args_03),
                   std::forward<t_ARGS_04>(args_04),
                   std::forward<t_ARGS_05>(args_05),
                   std::forward<t_ARGS_06>(args_06),
                   std::forward<t_ARGS_07>(args_07),
                   std::forward<t_ARGS_08>(args_08),
                   std::forward<t_ARGS_09>(args_09),
                   std::forward<t_ARGS_10>(args_10),
                   std::forward<t_ARGS_11>(args_11),
                   std::forward<t_ARGS_12>(args_12),
                   std::forward<t_ARGS_13>(args_13),
                   std::forward<t_ARGS_14>(args_14),
                   std::forward<t_ARGS_15>(args_15),
                   std::forward<t_ARGS_16>(args_16),
                   std::forward<t_ARGS_17>(args_17))
    {
    }
 
#else
 
    variant();
 
    variant(const variant& original);
 
    variant(BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(const t_TYPE&                                              value,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     const t_ARG_03&                                   arg_03,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::in_place_index_t<t_INDEX>, const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
    variant(bsl::allocator_arg_t, allocator_type allocator);
 
    variant(bsl::allocator_arg_t,
            allocator_type       allocator,
            const variant&       original);
    variant(bsl::allocator_arg_t,
            allocator_type                          allocator,
            BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          const t_TYPE&                                              value,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   const t_ARG_03&                                   arg_03,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
#endif
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class t_ARGS_16,
              class t_ARGS_17,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06,
                                                t_ARGS_07,
                                                t_ARGS_08,
                                                t_ARGS_09,
                                                t_ARGS_10,
                                                t_ARGS_11,
                                                t_ARGS_12,
                                                t_ARGS_13,
                                                t_ARGS_14,
                                                t_ARGS_15,
                                                t_ARGS_16,
                                                t_ARGS_17>::value> >
    t_TYPE& emplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_17) args_17)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_15, args_15),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_16, args_16),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_17, args_17));
 
        return bsl::get<index>(*this);
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class t_ARGS_16,
              class t_ARGS_17,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14,
                                        t_ARGS_15,
                                        t_ARGS_16,
                                        t_ARGS_17>::value> >
    t_TYPE& emplace(std::initializer_list<INIT_LIST_TYPE> il,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_17) args_17)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            il, BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_15, args_15),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_16, args_16),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_17, args_17));
 
        return bsl::get<index>(*this);
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class t_ARGS_16,
              class t_ARGS_17,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 17u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14,
                                        t_ARGS_15,
                                        t_ARGS_16,
                                        t_ARGS_17>::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17> >::type&
    emplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_17) args_17)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_15, args_15),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_16, args_16),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_17, args_17));
 
        return bsl::get<t_INDEX>(*this);
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class t_ARGS_16,
              class t_ARGS_17,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 17u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14,
                                        t_ARGS_15,
                                        t_ARGS_16,
                                        t_ARGS_17>::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17> >::type&
    emplace(std::initializer_list<INIT_LIST_TYPE> il,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_17) args_17)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            il, BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_15, args_15),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_16, args_16),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_17, args_17));
 
        return bsl::get<t_INDEX>(*this);
    }
 
#else
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace();
 
    template <class t_TYPE, class t_ARG_01>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
 
    template <size_t t_INDEX>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17> >::type&
    emplace();
 
    template <size_t t_INDEX, class t_ARG_01>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17> >::type&
    emplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17> >::type&
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
#endif
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    variant& operator=(const variant& rhs) = default;
 
    variant& operator=(variant&& rhs) = default;
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) value)
    {
        const size_t altIndex =
            BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
        if (index() == altIndex) {
            bsl::get<altIndex>(*this) = BSLS_COMPILERFEATURES_FORWARD(t_TYPE,
                                        value);
        }
        else {
            Variant_Base::template baseEmplace<altIndex>(
                BSLS_COMPILERFEATURES_FORWARD(t_TYPE, value));
        }
 
        return *this;
    }
#else
    variant& operator=(const variant& rhs);
 
    variant& operator=(BloombergLP::bslmf::MovableRef<variant> rhs);
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(const t_TYPE& value);
 
#endif
 
    void swap(variant& other);
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <bool t_USES_BSLMA_ALLOC = BloombergLP::bslstl::
                  Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09,
                                                        t_TAIL_10,
                                                        t_TAIL_11,
                                                        t_TAIL_12,
                                                        t_TAIL_13,
                                                        t_TAIL_14,
                                                        t_TAIL_15,
                                                        t_TAIL_16,
                                                        t_TAIL_17>::value,
              class = typename bsl::enable_if_t<t_USES_BSLMA_ALLOC> >
#endif
    allocator_type get_allocator() const BSLS_KEYWORD_NOEXCEPT
    {
        return allocator_type(Variant_Base::AllocBase::mechanism());
    }
 
 
    size_t index() const BSLS_KEYWORD_NOEXCEPT;
 
    bool valueless_by_exception() const BSLS_KEYWORD_NOEXCEPT;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
class variant<t_HEAD, t_TAIL_01,
                      t_TAIL_02,
                      t_TAIL_03,
                      t_TAIL_04,
                      t_TAIL_05,
                      t_TAIL_06,
                      t_TAIL_07,
                      t_TAIL_08,
                      t_TAIL_09,
                      t_TAIL_10,
                      t_TAIL_11,
                      t_TAIL_12,
                      t_TAIL_13,
                      t_TAIL_14,
                      t_TAIL_15,
                      t_TAIL_16,
                      t_TAIL_17,
                      t_TAIL_18>
: private BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                    t_TAIL_02,
                                                    t_TAIL_03,
                                                    t_TAIL_04,
                                                    t_TAIL_05,
                                                    t_TAIL_06,
                                                    t_TAIL_07,
                                                    t_TAIL_08,
                                                    t_TAIL_09,
                                                    t_TAIL_10,
                                                    t_TAIL_11,
                                                    t_TAIL_12,
                                                    t_TAIL_13,
                                                    t_TAIL_14,
                                                    t_TAIL_15,
                                                    t_TAIL_16,
                                                    t_TAIL_17,
                                                    t_TAIL_18>
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
,
  private BloombergLP::bslstl::Variant_SMFBase<
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17,
                                                          t_TAIL_18>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17,
                                                          t_TAIL_18>::value,
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17,
                                                          t_TAIL_18>::value &&
          BloombergLP::bslstl::Variant_IsCopyAssignableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14,
                                                           t_TAIL_15,
                                                           t_TAIL_16,
                                                           t_TAIL_17,
                                                           t_TAIL_18>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD,
                                                          t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17,
                                                          t_TAIL_18>::value &&
          BloombergLP::bslstl::Variant_IsMoveAssignableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14,
                                                           t_TAIL_15,
                                                           t_TAIL_16,
                                                           t_TAIL_17,
                                                           t_TAIL_18>::value>
#endif
{
  private:
    typedef BloombergLP::bslmf::MovableRefUtil                   MoveUtil;
    typedef BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16,
                                                      t_TAIL_17,
                                                      t_TAIL_18> Variant_Base;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD, t_TAIL_01,
                                                       t_TAIL_02,
                                                       t_TAIL_03,
                                                       t_TAIL_04,
                                                       t_TAIL_05,
                                                       t_TAIL_06,
                                                       t_TAIL_07,
                                                       t_TAIL_08,
                                                       t_TAIL_09,
                                                       t_TAIL_10,
                                                       t_TAIL_11,
                                                       t_TAIL_12,
                                                       t_TAIL_13,
                                                       t_TAIL_14,
                                                       t_TAIL_15,
                                                       t_TAIL_16,
                                                       t_TAIL_17,
                                                       t_TAIL_18>
        Variant_Union;
 
    friend struct BloombergLP::bslstl::Variant_ImpUtil;
 
    friend struct BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL_01,
                                                            t_TAIL_02,
                                                            t_TAIL_03,
                                                            t_TAIL_04,
                                                            t_TAIL_05,
                                                            t_TAIL_06,
                                                            t_TAIL_07,
                                                            t_TAIL_08,
                                                            t_TAIL_09,
                                                            t_TAIL_10,
                                                            t_TAIL_11,
                                                            t_TAIL_12,
                                                            t_TAIL_13,
                                                            t_TAIL_14,
                                                            t_TAIL_15,
                                                            t_TAIL_16,
                                                            t_TAIL_17,
                                                            t_TAIL_18>;
 
  public:
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11,
                                                   t_TAIL_12,
                                                   t_TAIL_13,
                                                   t_TAIL_14,
                                                   t_TAIL_15,
                                                   t_TAIL_16,
                                                   t_TAIL_17,
                                                   t_TAIL_18>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                   t_TAIL_02,
                                                   t_TAIL_03,
                                                   t_TAIL_04,
                                                   t_TAIL_05,
                                                   t_TAIL_06,
                                                   t_TAIL_07,
                                                   t_TAIL_08,
                                                   t_TAIL_09,
                                                   t_TAIL_10,
                                                   t_TAIL_11,
                                                   t_TAIL_12,
                                                   t_TAIL_13,
                                                   t_TAIL_14,
                                                   t_TAIL_15,
                                                   t_TAIL_16,
                                                   t_TAIL_17,
                                                   t_TAIL_18>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD,
                                                           t_TAIL_01,
                                                           t_TAIL_02,
                                                           t_TAIL_03,
                                                           t_TAIL_04,
                                                           t_TAIL_05,
                                                           t_TAIL_06,
                                                           t_TAIL_07,
                                                           t_TAIL_08,
                                                           t_TAIL_09,
                                                           t_TAIL_10,
                                                           t_TAIL_11,
                                                           t_TAIL_12,
                                                           t_TAIL_13,
                                                           t_TAIL_14,
                                                           t_TAIL_15,
                                                           t_TAIL_16,
                                                           t_TAIL_17,
                                                           t_TAIL_18>::value));
 
 
    typedef typename Variant_Base::allocator_type allocator_type;
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_FIRST_ALT = t_HEAD,
              class             = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST_ALT>::value> >
    variant()
    : Variant_Base()
    {
    }
 
    variant(const variant& original) = default;
 
    variant(variant&& original) = default;
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  BSLS_COMPILERFEATURES_FORWARD_REF(t_STD_VARIANT) original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) t,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class t_ARGS_16,
              class t_ARGS_17,
              class t_ARGS_18,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06,
                                                t_ARGS_07,
                                                t_ARGS_08,
                                                t_ARGS_09,
                                                t_ARGS_10,
                                                t_ARGS_11,
                                                t_ARGS_12,
                                                t_ARGS_13,
                                                t_ARGS_14,
                                                t_ARGS_15,
                                                t_ARGS_16,
                                                t_ARGS_17,
                                                t_ARGS_18>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_17) args_17,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_18) args_18)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_15, args_15),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_16, args_16),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_17, args_17),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_18, args_18))
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class t_ARGS_16,
              class t_ARGS_17,
              class t_ARGS_18,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14,
                                        t_ARGS_15,
                                        t_ARGS_16,
                                        t_ARGS_17,
                                        t_ARGS_18>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_17) args_17,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_18) args_18)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il,
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_15, args_15),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_16, args_16),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_17, args_17),
          BSLS_COMPILERFEATURES_FORWARD(t_ARGS_18, args_18))
    {
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class t_ARGS_16,
              class t_ARGS_17,
              class t_ARGS_18,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 18u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14,
                                        t_ARGS_15,
                                        t_ARGS_16,
                                        t_ARGS_17,
                                        t_ARGS_18>::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_17) args_17,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_18) args_18)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_15, args_15),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_16, args_16),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_17, args_17),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_18, args_18))
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class t_ARGS_16,
              class t_ARGS_17,
              class t_ARGS_18,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 18u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14,
                                        t_ARGS_15,
                                        t_ARGS_16,
                                        t_ARGS_17,
                                        t_ARGS_18>::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_17) args_17,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_18) args_18)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   il,
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_15, args_15),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_16, args_16),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_17, args_17),
                   BSLS_COMPILERFEATURES_FORWARD(t_ARGS_18, args_18))
    {
    }
 
    template <class FIRST = t_HEAD,
              class       = typename bsl::enable_if_t<
                  std::is_default_constructible<FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }
 
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<FIRST, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16,
                                                      t_TAIL_17,
                                                      t_TAIL_18>::value> >
    variant(bsl::allocator_arg_t,
            allocator_type allocator,
            const variant& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, original)
    {
    }
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<FIRST, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16,
                                                      t_TAIL_17,
                                                      t_TAIL_18>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator, variant&& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, std::move(original))
    {
    }
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  bsl::allocator_arg_t,
                  allocator_type  allocator,
                  BSLS_COMPILERFEATURES_FORWARD_REF(t_STD_VARIANT) original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(bsl::allocator_arg_t(),
                   allocator,
                   BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) t,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class t_ARGS_16,
              class t_ARGS_17,
              class t_ARGS_18,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06,
                                                t_ARGS_07,
                                                t_ARGS_08,
                                                t_ARGS_09,
                                                t_ARGS_10,
                                                t_ARGS_11,
                                                t_ARGS_12,
                                                t_ARGS_13,
                                                t_ARGS_14,
                                                t_ARGS_15,
                                                t_ARGS_16,
                                                t_ARGS_17,
                                                t_ARGS_18>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_17) args_17,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_18) args_18)
    : Variant_Base(
          bsl::allocator_arg_t{}
,
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          std::forward<t_ARGS_01>(args_01),
          std::forward<t_ARGS_02>(args_02),
          std::forward<t_ARGS_03>(args_03),
          std::forward<t_ARGS_04>(args_04),
          std::forward<t_ARGS_05>(args_05),
          std::forward<t_ARGS_06>(args_06),
          std::forward<t_ARGS_07>(args_07),
          std::forward<t_ARGS_08>(args_08),
          std::forward<t_ARGS_09>(args_09),
          std::forward<t_ARGS_10>(args_10),
          std::forward<t_ARGS_11>(args_11),
          std::forward<t_ARGS_12>(args_12),
          std::forward<t_ARGS_13>(args_13),
          std::forward<t_ARGS_14>(args_14),
          std::forward<t_ARGS_15>(args_15),
          std::forward<t_ARGS_16>(args_16),
          std::forward<t_ARGS_17>(args_17),
          std::forward<t_ARGS_18>(args_18))
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class t_ARGS_16,
              class t_ARGS_17,
              class t_ARGS_18,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14,
                                        t_ARGS_15,
                                        t_ARGS_16,
                                        t_ARGS_17,
                                        t_ARGS_18>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_17) args_17,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_18) args_18)
    : Variant_Base(
          bsl::allocator_arg_t{}
,
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il,
          std::forward<t_ARGS_01>(args_01),
          std::forward<t_ARGS_02>(args_02),
          std::forward<t_ARGS_03>(args_03),
          std::forward<t_ARGS_04>(args_04),
          std::forward<t_ARGS_05>(args_05),
          std::forward<t_ARGS_06>(args_06),
          std::forward<t_ARGS_07>(args_07),
          std::forward<t_ARGS_08>(args_08),
          std::forward<t_ARGS_09>(args_09),
          std::forward<t_ARGS_10>(args_10),
          std::forward<t_ARGS_11>(args_11),
          std::forward<t_ARGS_12>(args_12),
          std::forward<t_ARGS_13>(args_13),
          std::forward<t_ARGS_14>(args_14),
          std::forward<t_ARGS_15>(args_15),
          std::forward<t_ARGS_16>(args_16),
          std::forward<t_ARGS_17>(args_17),
          std::forward<t_ARGS_18>(args_18))
    {
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class t_ARGS_16,
              class t_ARGS_17,
              class t_ARGS_18,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 18u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14,
                                        t_ARGS_15,
                                        t_ARGS_16,
                                        t_ARGS_17,
                                        t_ARGS_18>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_17) args_17,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_18) args_18)
    : Variant_Base(bsl::allocator_arg_t{}
,
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   std::forward<t_ARGS_01>(args_01),
                   std::forward<t_ARGS_02>(args_02),
                   std::forward<t_ARGS_03>(args_03),
                   std::forward<t_ARGS_04>(args_04),
                   std::forward<t_ARGS_05>(args_05),
                   std::forward<t_ARGS_06>(args_06),
                   std::forward<t_ARGS_07>(args_07),
                   std::forward<t_ARGS_08>(args_08),
                   std::forward<t_ARGS_09>(args_09),
                   std::forward<t_ARGS_10>(args_10),
                   std::forward<t_ARGS_11>(args_11),
                   std::forward<t_ARGS_12>(args_12),
                   std::forward<t_ARGS_13>(args_13),
                   std::forward<t_ARGS_14>(args_14),
                   std::forward<t_ARGS_15>(args_15),
                   std::forward<t_ARGS_16>(args_16),
                   std::forward<t_ARGS_17>(args_17),
                   std::forward<t_ARGS_18>(args_18))
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class t_ARGS_16,
              class t_ARGS_17,
              class t_ARGS_18,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 18u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14,
                                        t_ARGS_15,
                                        t_ARGS_16,
                                        t_ARGS_17,
                                        t_ARGS_18>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_17) args_17,
                     BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_18) args_18)
    : Variant_Base(bsl::allocator_arg_t{}
,
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   il,
                   std::forward<t_ARGS_01>(args_01),
                   std::forward<t_ARGS_02>(args_02),
                   std::forward<t_ARGS_03>(args_03),
                   std::forward<t_ARGS_04>(args_04),
                   std::forward<t_ARGS_05>(args_05),
                   std::forward<t_ARGS_06>(args_06),
                   std::forward<t_ARGS_07>(args_07),
                   std::forward<t_ARGS_08>(args_08),
                   std::forward<t_ARGS_09>(args_09),
                   std::forward<t_ARGS_10>(args_10),
                   std::forward<t_ARGS_11>(args_11),
                   std::forward<t_ARGS_12>(args_12),
                   std::forward<t_ARGS_13>(args_13),
                   std::forward<t_ARGS_14>(args_14),
                   std::forward<t_ARGS_15>(args_15),
                   std::forward<t_ARGS_16>(args_16),
                   std::forward<t_ARGS_17>(args_17),
                   std::forward<t_ARGS_18>(args_18))
    {
    }
 
#else
 
    variant();
 
    variant(const variant& original);
 
    variant(BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(const t_TYPE&                                              value,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     const t_ARG_03&                                   arg_03,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::in_place_index_t<t_INDEX>, const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
    variant(bsl::allocator_arg_t, allocator_type allocator);
 
    variant(bsl::allocator_arg_t,
            allocator_type       allocator,
            const variant&       original);
    variant(bsl::allocator_arg_t,
            allocator_type                          allocator,
            BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          const t_TYPE&                                              value,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   const t_ARG_03&                                   arg_03,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
#endif
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class t_ARGS_16,
              class t_ARGS_17,
              class t_ARGS_18,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS_01,
                                                t_ARGS_02,
                                                t_ARGS_03,
                                                t_ARGS_04,
                                                t_ARGS_05,
                                                t_ARGS_06,
                                                t_ARGS_07,
                                                t_ARGS_08,
                                                t_ARGS_09,
                                                t_ARGS_10,
                                                t_ARGS_11,
                                                t_ARGS_12,
                                                t_ARGS_13,
                                                t_ARGS_14,
                                                t_ARGS_15,
                                                t_ARGS_16,
                                                t_ARGS_17,
                                                t_ARGS_18>::value> >
    t_TYPE& emplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_17) args_17,
                    BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_18) args_18)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_15, args_15),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_16, args_16),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_17, args_17),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_18, args_18));
 
        return bsl::get<index>(*this);
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class t_ARGS_16,
              class t_ARGS_17,
              class t_ARGS_18,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14,
                                        t_ARGS_15,
                                        t_ARGS_16,
                                        t_ARGS_17,
                                        t_ARGS_18>::value> >
    t_TYPE& emplace(std::initializer_list<INIT_LIST_TYPE> il,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_17) args_17,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_18) args_18)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            il, BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_15, args_15),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_16, args_16),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_17, args_17),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_18, args_18));
 
        return bsl::get<index>(*this);
    }
 
    template <size_t   t_INDEX,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class t_ARGS_16,
              class t_ARGS_17,
              class t_ARGS_18,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 18u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14,
                                        t_ARGS_15,
                                        t_ARGS_16,
                                        t_ARGS_17,
                                        t_ARGS_18>::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17,
                                                          t_TAIL_18> >::type&
    emplace(BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_17) args_17,
            BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_18) args_18)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_15, args_15),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_16, args_16),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_17, args_17),
            BSLS_COMPILERFEATURES_FORWARD(t_ARGS_18, args_18));
 
        return bsl::get<t_INDEX>(*this);
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class t_ARGS_01,
              class t_ARGS_02,
              class t_ARGS_03,
              class t_ARGS_04,
              class t_ARGS_05,
              class t_ARGS_06,
              class t_ARGS_07,
              class t_ARGS_08,
              class t_ARGS_09,
              class t_ARGS_10,
              class t_ARGS_11,
              class t_ARGS_12,
              class t_ARGS_13,
              class t_ARGS_14,
              class t_ARGS_15,
              class t_ARGS_16,
              class t_ARGS_17,
              class t_ARGS_18,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + 18u) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS_01,
                                        t_ARGS_02,
                                        t_ARGS_03,
                                        t_ARGS_04,
                                        t_ARGS_05,
                                        t_ARGS_06,
                                        t_ARGS_07,
                                        t_ARGS_08,
                                        t_ARGS_09,
                                        t_ARGS_10,
                                        t_ARGS_11,
                                        t_ARGS_12,
                                        t_ARGS_13,
                                        t_ARGS_14,
                                        t_ARGS_15,
                                        t_ARGS_16,
                                        t_ARGS_17,
                                        t_ARGS_18>::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17,
                                                          t_TAIL_18> >::type&
    emplace(std::initializer_list<INIT_LIST_TYPE> il,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_01) args_01,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_02) args_02,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_03) args_03,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_04) args_04,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_05) args_05,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_06) args_06,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_07) args_07,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_08) args_08,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_09) args_09,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_10) args_10,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_11) args_11,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_12) args_12,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_13) args_13,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_14) args_14,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_15) args_15,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_16) args_16,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_17) args_17,
                          BSLS_COMPILERFEATURES_FORWARD_REF(t_ARGS_18) args_18)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            il, BSLS_COMPILERFEATURES_FORWARD(t_ARGS_01, args_01),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_02, args_02),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_03, args_03),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_04, args_04),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_05, args_05),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_06, args_06),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_07, args_07),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_08, args_08),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_09, args_09),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_10, args_10),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_11, args_11),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_12, args_12),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_13, args_13),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_14, args_14),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_15, args_15),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_16, args_16),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_17, args_17),
                BSLS_COMPILERFEATURES_FORWARD(t_ARGS_18, args_18));
 
        return bsl::get<t_INDEX>(*this);
    }
 
#else
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace();
 
    template <class t_TYPE, class t_ARG_01>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
 
    template <size_t t_INDEX>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17,
                                                          t_TAIL_18> >::type&
    emplace();
 
    template <size_t t_INDEX, class t_ARG_01>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17,
                                                          t_TAIL_18> >::type&
    emplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17,
                                                          t_TAIL_18> >::type&
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17,
                                                          t_TAIL_18> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17,
                                                          t_TAIL_18> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17,
                                                          t_TAIL_18> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17,
                                                          t_TAIL_18> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17,
                                                          t_TAIL_18> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17,
                                                          t_TAIL_18> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17,
                                                          t_TAIL_18> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17,
                                                          t_TAIL_18> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
#endif
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    variant& operator=(const variant& rhs) = default;
 
    variant& operator=(variant&& rhs) = default;
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(BSLS_COMPILERFEATURES_FORWARD_REF(t_TYPE) value)
    {
        const size_t altIndex =
            BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
        if (index() == altIndex) {
            bsl::get<altIndex>(*this) = BSLS_COMPILERFEATURES_FORWARD(t_TYPE,
                                        value);
        }
        else {
            Variant_Base::template baseEmplace<altIndex>(
                BSLS_COMPILERFEATURES_FORWARD(t_TYPE, value));
        }
 
        return *this;
    }
#else
    variant& operator=(const variant& rhs);
 
    variant& operator=(BloombergLP::bslmf::MovableRef<variant> rhs);
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(const t_TYPE& value);
 
#endif
 
    void swap(variant& other);
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <bool t_USES_BSLMA_ALLOC = BloombergLP::bslstl::
                  Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                        t_TAIL_02,
                                                        t_TAIL_03,
                                                        t_TAIL_04,
                                                        t_TAIL_05,
                                                        t_TAIL_06,
                                                        t_TAIL_07,
                                                        t_TAIL_08,
                                                        t_TAIL_09,
                                                        t_TAIL_10,
                                                        t_TAIL_11,
                                                        t_TAIL_12,
                                                        t_TAIL_13,
                                                        t_TAIL_14,
                                                        t_TAIL_15,
                                                        t_TAIL_16,
                                                        t_TAIL_17,
                                                        t_TAIL_18>::value,
              class = typename bsl::enable_if_t<t_USES_BSLMA_ALLOC> >
#endif
    allocator_type get_allocator() const BSLS_KEYWORD_NOEXCEPT
    {
        return allocator_type(Variant_Base::AllocBase::mechanism());
    }
 
 
    size_t index() const BSLS_KEYWORD_NOEXCEPT;
 
    bool valueless_by_exception() const BSLS_KEYWORD_NOEXCEPT;
};
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 18
 
#else
// The generated code below is a workaround for the absence of perfect
// forwarding in some compilers.
template <class t_HEAD, class... t_TAIL>
class variant
: private BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL...>
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
,
  private BloombergLP::bslstl::Variant_SMFBase<
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD,
                                                          t_TAIL...>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD,
                                                          t_TAIL...>::value,
      BloombergLP::bslstl::Variant_IsCopyConstructibleAll<t_HEAD,
                                                          t_TAIL...>::value &&
          BloombergLP::bslstl::Variant_IsCopyAssignableAll<t_HEAD,
                                                           t_TAIL...>::value,
      BloombergLP::bslstl::Variant_IsMoveConstructibleAll<t_HEAD,
                                                          t_TAIL...>::value &&
          BloombergLP::bslstl::Variant_IsMoveAssignableAll<t_HEAD,
                                                           t_TAIL...>::value>
#endif
{
  private:
    typedef BloombergLP::bslmf::MovableRefUtil                   MoveUtil;
    typedef BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL...> Variant_Base;
    typedef BloombergLP::bslstl::Variant_Union<t_HEAD, t_TAIL...>
        Variant_Union;
 
    friend struct BloombergLP::bslstl::Variant_ImpUtil;
 
    friend struct BloombergLP::bslstl::Variant_Base<t_HEAD, t_TAIL...>;
 
  public:
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslma::UsesBslmaAllocator,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL...>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::UsesAllocatorArgT,
        (BloombergLP::bslstl::
             Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL...>::value));
    BSLMF_NESTED_TRAIT_DECLARATION_IF(
        variant,
        BloombergLP::bslmf::IsBitwiseMoveable,
        (BloombergLP::bslstl::Variant_IsBitwiseMoveableAll<t_HEAD,
                                                           t_TAIL...>::value));
 
 
    typedef typename Variant_Base::allocator_type allocator_type;
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_FIRST_ALT = t_HEAD,
              class             = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST_ALT>::value> >
    variant()
    : Variant_Base()
    {
    }
 
    variant(const variant& original) = default;
 
    variant(variant&& original) = default;
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  t_STD_VARIANT&& original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(t_TYPE&& t,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class... t_ARGS,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS...>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>, t_ARGS&&... args)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          std::forward<t_ARGS>(args)...)
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class... t_ARGS,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS...>::value> >
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     t_ARGS&&...                           args)
    : Variant_Base(
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il,
          std::forward<t_ARGS>(args)...)
    {
    }
 
    template <size_t   t_INDEX,
              class... t_ARGS,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + sizeof...(t_TAIL)) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS...>::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>, t_ARGS&&... args)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   std::forward<t_ARGS>(args)...)
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class... t_ARGS,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + sizeof...(t_TAIL)) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS...>::value> >
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     t_ARGS&&...                           args)
    : Variant_Base(bsl::in_place_index_t<t_INDEX>(),
                   il,
                   std::forward<t_ARGS>(args)...)
    {
    }
 
    template <class FIRST = t_HEAD,
              class       = typename bsl::enable_if_t<
                  std::is_default_constructible<FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }
 
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<FIRST, t_TAIL...>::value> >
    variant(bsl::allocator_arg_t,
            allocator_type allocator,
            const variant& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, original)
    {
    }
    template <
        class FIRST = t_HEAD,
        class       = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<FIRST, t_TAIL...>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator, variant&& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, std::move(original))
    {
    }
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
    template <class t_STD_VARIANT>
    explicit variant(
                  bsl::allocator_arg_t,
                  allocator_type  allocator,
                  t_STD_VARIANT&& original,
                  BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM_STD(t_STD_VARIANT))
    : Variant_Base(bsl::allocator_arg_t(),
                   allocator,
                   BloombergLP::bslstl::Variant_ConstructFromStdTag(),
                   original.index())
    {
        if (!valueless_by_exception()) {
            BloombergLP::bslstl::Variant_ImpUtil::
                ConstructFromStdVisitor<variant, decltype(original)>
                    visitor(*this, original);
            BSLSTL_VARIANT_VISITID(void, visitor, *this);
        }
    }
#endif
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          t_TYPE&&                                                   t,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE,
              class... t_ARGS,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS...>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     t_ARGS&&... args)
    : Variant_Base(
          bsl::allocator_arg_t{},
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          std::forward<t_ARGS>(args)...)
    {
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class... t_ARGS,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS...>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     t_ARGS&&...                           args)
    : Variant_Base(
          bsl::allocator_arg_t{},
          allocator,
          bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
          il,
          std::forward<t_ARGS>(args)...)
    {
    }
 
    template <size_t   t_INDEX,
              class... t_ARGS,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + sizeof...(t_TAIL)) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS...>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     t_ARGS&&... args)
    : Variant_Base(bsl::allocator_arg_t{},
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   std::forward<t_ARGS>(args)...)
    {
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class... t_ARGS,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + sizeof...(t_TAIL)) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS...>::value> >
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     std::initializer_list<INIT_LIST_TYPE> il,
                     t_ARGS&&...                           args)
    : Variant_Base(bsl::allocator_arg_t{},
                   allocator,
                   bsl::in_place_index_t<t_INDEX>(),
                   il,
                   std::forward<t_ARGS>(args)...)
    {
    }
 
#else
 
    variant();
 
    variant(const variant& original);
 
    variant(BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(const t_TYPE&                                              value,
            BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01&                                   arg_01,
                     const t_ARG_02&                                   arg_02,
                     const t_ARG_03&                                   arg_03,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::in_place_index_t<t_INDEX>, const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
    variant(bsl::allocator_arg_t, allocator_type allocator);
 
    variant(bsl::allocator_arg_t,
            allocator_type       allocator,
            const variant&       original);
    variant(bsl::allocator_arg_t,
            allocator_type                          allocator,
            BloombergLP::bslmf::MovableRef<variant> original);
 
    template <class t_TYPE>
    variant(
          bsl::allocator_arg_t,
          allocator_type                                             allocator,
          const t_TYPE&                                              value,
          BSLSTL_VARIANT_DECLARE_IF_CONSTRUCTS_FROM(variant, t_TYPE));
 
    template <class t_TYPE>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(
                   bsl::allocator_arg_t,
                   allocator_type                                    allocator,
                   bsl::in_place_type_t<t_TYPE>,
                   const t_ARG_01&                                   arg_01,
                   const t_ARG_02&                                   arg_02,
                   const t_ARG_03&                                   arg_03,
                   BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_type_t<t_TYPE>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10,
                     BSLSTL_VARIANT_DECLARE_IF_HAS_UNIQUE_TYPE(t_TYPE));
 
    template <size_t t_INDEX>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>);
 
    template <size_t t_INDEX, class t_ARG_01>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type                 allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01&                arg_01,
                     const t_ARG_02&                arg_02,
                     const t_ARG_03&                arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    explicit variant(bsl::allocator_arg_t,
                     allocator_type allocator,
                     bsl::in_place_index_t<t_INDEX>,
                     const t_ARG_01& arg_01,
                     const t_ARG_02& arg_02,
                     const t_ARG_03& arg_03,
                     const t_ARG_04& arg_04,
                     const t_ARG_05& arg_05,
                     const t_ARG_06& arg_06,
                     const t_ARG_07& arg_07,
                     const t_ARG_08& arg_08,
                     const t_ARG_09& arg_09,
                     const t_ARG_10& arg_10);
 
#endif
 
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <class t_TYPE,
              class... t_ARGS,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE, t_ARGS...>::value> >
    t_TYPE& emplace(t_ARGS&&... args)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            std::forward<t_ARGS>(args)...);
 
        return bsl::get<index>(*this);
    }
 
    template <class t_TYPE,
              class INIT_LIST_TYPE,
              class... t_ARGS,
              class = typename bsl::enable_if_t<
                  BSLSTL_VARIANT_HAS_UNIQUE_TYPE(t_TYPE) &&
                  std::is_constructible<t_TYPE,
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS...>::value> >
    t_TYPE& emplace(std::initializer_list<INIT_LIST_TYPE> il, t_ARGS&&... args)
    {
        const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
        Variant_Base::template baseEmplace<index>(
            il, std::forward<t_ARGS>(args)...);
 
        return bsl::get<index>(*this);
    }
 
    template <size_t   t_INDEX,
              class... t_ARGS,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + sizeof...(t_TAIL)) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        t_ARGS...>::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL...> >::type&
    emplace(t_ARGS&&... args)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            std::forward<t_ARGS>(args)...);
 
        return bsl::get<t_INDEX>(*this);
    }
 
    template <size_t t_INDEX,
              class INIT_LIST_TYPE,
              class... t_ARGS,
              class = typename bsl::enable_if_t<
                  (t_INDEX < 1 + sizeof...(t_TAIL)) &&
                  std::is_constructible<BSLSTL_VARIANT_TYPE_AT_INDEX(t_INDEX),
                                        std::initializer_list<INIT_LIST_TYPE>&,
                                        t_ARGS...>::value> >
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL...> >::type&
    emplace(std::initializer_list<INIT_LIST_TYPE> il, t_ARGS&&... args)
    {
        Variant_Base::template baseEmplace<t_INDEX>(
            il, std::forward<t_ARGS>(args)...);
 
        return bsl::get<t_INDEX>(*this);
    }
 
#else
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace();
 
    template <class t_TYPE, class t_ARG_01>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <class t_TYPE,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, variant>::value,
        t_TYPE&>::type
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
 
    template <size_t t_INDEX>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL...> >::type&
    emplace();
 
    template <size_t t_INDEX, class t_ARG_01>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL...> >::type&
    emplace(const t_ARG_01& arg_01);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL...> >::type&
    emplace(const t_ARG_01& arg_01, const t_ARG_02& arg_02);
 
    template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL...> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL...> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL...> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL...> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL...> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL...> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL...> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09);
 
    template <size_t t_INDEX,
              class t_ARG_01,
              class t_ARG_02,
              class t_ARG_03,
              class t_ARG_04,
              class t_ARG_05,
              class t_ARG_06,
              class t_ARG_07,
              class t_ARG_08,
              class t_ARG_09,
              class t_ARG_10>
    typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL...> >::type&
    emplace(const t_ARG_01& arg_01,
            const t_ARG_02& arg_02,
            const t_ARG_03& arg_03,
            const t_ARG_04& arg_04,
            const t_ARG_05& arg_05,
            const t_ARG_06& arg_06,
            const t_ARG_07& arg_07,
            const t_ARG_08& arg_08,
            const t_ARG_09& arg_09,
            const t_ARG_10& arg_10);
#endif
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    variant& operator=(const variant& rhs) = default;
 
    variant& operator=(variant&& rhs) = default;
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(t_TYPE&& value)
    {
        const size_t altIndex =
            BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
        if (index() == altIndex) {
            bsl::get<altIndex>(*this) = std::forward<t_TYPE>(value);
        }
        else {
            Variant_Base::template baseEmplace<altIndex>(
                std::forward<t_TYPE>(value));
        }
 
        return *this;
    }
#else
    variant& operator=(const variant& rhs);
 
    variant& operator=(BloombergLP::bslmf::MovableRef<variant> rhs);
 
    template <class t_TYPE>
    typename bsl::enable_if<
        BloombergLP::bslstl::Variant_AssignsFromType<variant, t_TYPE>::value,
        variant&>::type
    operator=(const t_TYPE& value);
 
#endif
 
    void swap(variant& other);
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
    template <bool t_USES_BSLMA_ALLOC = BloombergLP::bslstl::
                  Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL...>::value,
              class = typename bsl::enable_if_t<t_USES_BSLMA_ALLOC> >
#endif
    allocator_type get_allocator() const BSLS_KEYWORD_NOEXCEPT
    {
        return allocator_type(Variant_Base::AllocBase::mechanism());
    }
 
 
    size_t index() const BSLS_KEYWORD_NOEXCEPT;
 
    bool valueless_by_exception() const BSLS_KEYWORD_NOEXCEPT;
};
 
// }}} END GENERATED CODE
#endif
 
}  // close namespace bsl
 
// ============================================================================
//                           INLINE DEFINITIONS
// ============================================================================
 
 
namespace bslstl {
 
                           // ---------------------
                           // class Variant_ImpUtil
                           // ---------------------
 
template <class t_RET, class t_VARIANT_UNION>
t_RET& Variant_ImpUtil::getAlternative(
                   bsl::in_place_index_t<0>,
                   t_VARIANT_UNION&         variantUnion) BSLS_KEYWORD_NOEXCEPT
{
    return variantUnion.d_head.value();
}
 
template <class t_RET, size_t t_INDEX, class t_VARIANT_UNION>
t_RET& Variant_ImpUtil::getAlternative(
             bsl::in_place_index_t<t_INDEX>,
             t_VARIANT_UNION&               variantUnion) BSLS_KEYWORD_NOEXCEPT
{
    return getAlternative<t_RET>(bsl::in_place_index_t<t_INDEX - 1>(),
                                 variantUnion.d_tail);
}
 
template <class t_RET, size_t t_INDEX, class t_VARIANT>
t_RET& Variant_ImpUtil::get(t_VARIANT& variant)
{
    if (variant.index() != t_INDEX) {
        BSLS_THROW(bsl::bad_variant_access());
    }
 
    return getAlternative<t_RET>(bsl::in_place_index_t<t_INDEX>(),
                                 variant.d_union);
}
 
template <class t_RET, size_t t_INDEX, class t_VARIANT>
t_RET& Variant_ImpUtil::get(const t_VARIANT& variant)
{
    if (variant.index() != t_INDEX) {
        BSLS_THROW(bsl::bad_variant_access());
    }
 
    return getAlternative<t_RET>(bsl::in_place_index_t<t_INDEX>(),
                                 variant.d_union);
}
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
template <class t_RET, class t_VISITOR, class t_VARIANT>
t_RET Variant_ImpUtil::visit(t_VISITOR&& visitor, t_VARIANT&& variant)
{
    static constexpr size_t varSize =
        bsl::variant_size<bsl::remove_reference_t<t_VARIANT> >::value;
 
    typedef typename Variant_VTable<
        t_RET,
        t_VISITOR&&,
        t_VARIANT&&,
        bslmf::MakeIntegerSequence<std::size_t, varSize> >::FuncPtr FuncPtr;
 
    // Generate the table of all function pointers for 't_VISITOR' and
    // 't_VARIANT', then invoke the one corresponding to the active index.
    FuncPtr funcPtr =
        Variant_VTable<t_RET,
                       t_VISITOR&&,
                       t_VARIANT&&,
                       bslmf::MakeIntegerSequence<std::size_t, varSize> >::
            s_map[variant.index()];
 
    return (*funcPtr)(std::forward<t_VISITOR>(visitor),
                      std::forward<t_VARIANT>(variant));
}
template <class t_RET, class t_VISITOR, class t_VARIANT>
t_RET Variant_ImpUtil::visitId(t_VISITOR&& visitor, t_VARIANT&& variant)
{
    static constexpr size_t varSize =
        bsl::variant_size<bsl::remove_reference_t<t_VARIANT> >::value;
 
    typedef typename Variant_VTableId<
        t_RET,
        t_VISITOR&&,
        t_VARIANT&&,
        bslmf::MakeIntegerSequence<std::size_t, varSize> >::FuncPtr FuncPtr;
 
    FuncPtr funcPtr =
        Variant_VTableId<t_RET,
                         t_VISITOR&&,
                         t_VARIANT&&,
                         bslmf::MakeIntegerSequence<std::size_t, varSize> >::
            s_mapId[variant.index()];
 
    return (*funcPtr)(std::forward<t_VISITOR>(visitor),
                      std::forward<t_VARIANT>(variant));
}
 
#else
template <class t_RET, size_t t_INDEX, class t_VARIANT>
t_RET& Variant_ImpUtil::unsafeGet(t_VARIANT& variant)
{
    return getAlternative<t_RET>(bsl::in_place_index_t<t_INDEX>(),
                                 variant.d_union);
}
 
template <class t_RET, size_t t_INDEX, class t_VARIANT>
t_RET& Variant_ImpUtil::unsafeGet(const t_VARIANT& variant)
{
    return getAlternative<t_RET>(bsl::in_place_index_t<t_INDEX>(),
                                 variant.d_union);
}
 
template <class t_TYPE, class t_VARIANT>
t_TYPE& Variant_ImpUtil::unsafeGet(t_VARIANT& obj)
{
    return unsafeGet<t_TYPE, BSLSTL_VARIANT_INDEX_OF(t_TYPE, t_VARIANT)>(
                                                                          obj);
}
 
template <class t_TYPE, class t_VARIANT>
const t_TYPE& Variant_ImpUtil::unsafeGet(const t_VARIANT& obj)
{
    return unsafeGet<const t_TYPE, BSLSTL_VARIANT_INDEX_OF(t_TYPE, t_VARIANT)>(
                                                                          obj);
}
 
template <class t_RET, class t_VISITOR, class t_VARIANT>
t_RET Variant_ImpUtil::visit(t_VISITOR& visitor, t_VARIANT& variant)
{
    typedef
        typename Variant_VTable<t_RET, t_VISITOR, t_VARIANT>::FuncPtr FuncPtr;
 
    // Generate the table of all function pointers for 't_VISITOR' and
    // 't_VARIANT', then invoke the one corresponding to the active index.
    FuncPtr funcPtr =
        Variant_VTable<t_RET, t_VISITOR, t_VARIANT>::map()[variant.index()];
 
    return (*funcPtr)(visitor, variant);
}
 
template <class t_RET, class t_VISITOR, class t_VARIANT>
t_RET Variant_ImpUtil::visit(t_VISITOR& visitor, const t_VARIANT& variant)
{
    typedef typename Variant_VTable<t_RET, t_VISITOR, const t_VARIANT>::FuncPtr
        FuncPtr;
 
    // Generate the table of all function pointers for 't_VISITOR' and
    // 't_VARIANT', then invoke the one corresponding to the active index.
    FuncPtr funcPtr =
        Variant_VTable<t_RET, t_VISITOR, const t_VARIANT>::map()[variant
                                                                     .index()];
 
    return (*funcPtr)(visitor, variant);
}
 
template <class t_RET, class t_VISITOR, class t_VARIANT>
t_RET Variant_ImpUtil::moveVisit(t_VISITOR& visitor, t_VARIANT& variant)
{
    typedef
        typename Variant_VTable<t_RET, t_VISITOR, t_VARIANT>::FuncPtr FuncPtr;
 
    // Generate the table of all function pointers for 't_VISITOR' and
    // 't_VARIANT', then invoke the one corresponding to the active index.
    FuncPtr funcPtr =
        Variant_VTable<t_RET, t_VISITOR, t_VARIANT>::moveMap()[variant
                                                                   .index()];
 
    return (*funcPtr)(visitor, variant);
}
 
// The visitation functions below are the same as the ones above except that
// the visitor is invoked with an additional argument of type
// 'bsl::in_place_index_t'.  They are used internally for visitors that
// participate in the 'variant' implementation.
template <class t_RET, class t_VISITOR, class t_VARIANT>
t_RET Variant_ImpUtil::visitId(t_VISITOR& visitor, t_VARIANT& variant)
{
    typedef
        typename Variant_VTable<t_RET, t_VISITOR, t_VARIANT>::FuncPtr FuncPtr;
 
    FuncPtr funcPtr =
        Variant_VTable<t_RET, t_VISITOR, t_VARIANT>::mapId()[variant.index()];
 
    return (*funcPtr)(visitor, variant);
}
 
template <class t_RET, class t_VISITOR, class t_VARIANT>
t_RET Variant_ImpUtil::visitId(t_VISITOR& visitor, const t_VARIANT& variant)
{
    typedef typename Variant_VTable<t_RET, t_VISITOR, const t_VARIANT>::FuncPtr
        FuncPtr;
 
    FuncPtr funcPtr = Variant_VTable<t_RET, t_VISITOR, const t_VARIANT>::
        mapId()[variant.index()];
 
    return (*funcPtr)(visitor, variant);
}
 
#endif  // BSL_VARIANT_FULL_IMPLEMENTATION
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
               // ----------------------------------------------
               // class Variant_ImpUtil::ConstructFromStdVisitor
               // ----------------------------------------------
 
template <class t_VARIANT, class t_STD_VARIANT>
Variant_ImpUtil::ConstructFromStdVisitor<t_VARIANT, t_STD_VARIANT>::
    ConstructFromStdVisitor(t_VARIANT& target, t_STD_VARIANT& original)
: d_target(target)
, d_original(original)
{
}
 
template <class t_VARIANT, class t_STD_VARIANT>
template <size_t t_INDEX, class t_TYPE>
void
Variant_ImpUtil::ConstructFromStdVisitor<t_VARIANT, t_STD_VARIANT>::
    operator()(bsl::in_place_index_t<t_INDEX>, t_TYPE&) const
{
    // Implementation note: calling the correct overload of 'operator()' is
    // made possible only by the fact that we have set 'd_target.d_type' to
    // 'd_original.index()' prior to invoking the visitor.  But we must now use
    // private access to 'd_target' to set the index to -1 before we call
    // 'baseEmplace' (otherwise, 'baseEmplace' would attempt to destroy the
    // alternative first before constructing a new one).
 
    d_target.d_type = bsl::variant_npos;
    d_target.template baseEmplace<t_INDEX>(
               std::get<t_INDEX>(std::forward<t_STD_VARIANT>(d_original)));
}
#endif  // BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
 
                          // ------------------------
                          // class Variant_NoSuchType
                          // ------------------------
 
// CREATORS
inline
BSLS_KEYWORD_CONSTEXPR Variant_NoSuchType::Variant_NoSuchType(
                                                     int) BSLS_KEYWORD_NOEXCEPT
{
}
 
                           // ---------------------
                           // class Variant_DataImp
                           // ---------------------
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
// CREATORS
template <class t_TYPE>
template <class... t_ARGS>
inline
Variant_DataImp<t_TYPE>::Variant_DataImp(t_ARGS&&... args)
{
    BloombergLP::bslma::ConstructionUtil::construct(
        d_buffer.address(), std::forward<t_ARGS>(args)...);
}
#endif  // BSL_VARIANT_FULL_IMPLEMENTATION
 
// MANIPULATORS
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
template <class t_TYPE>
inline
BSLS_KEYWORD_CONSTEXPR_CPP14 t_TYPE& Variant_DataImp<t_TYPE>::value() &
{
    return d_buffer.object();
}
 
template <class t_TYPE>
inline
BSLS_KEYWORD_CONSTEXPR_CPP14 t_TYPE&& Variant_DataImp<t_TYPE>::value() &&
{
    return std::move(d_buffer.object());
}
#else   // BSL_VARIANT_FULL_IMPLEMENTATION
template <class t_TYPE>
inline
t_TYPE& Variant_DataImp<t_TYPE>::value()
{
    return d_buffer.object();
}
#endif  // BSL_VARIANT_FULL_IMPLEMENTATION
 
// ACCESSORS
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
template <class t_TYPE>
inline
BSLS_KEYWORD_CONSTEXPR_CPP14 const t_TYPE& Variant_DataImp<t_TYPE>::value()
const&
{
    return d_buffer.object();
}
 
template <class t_TYPE>
inline
BSLS_KEYWORD_CONSTEXPR_CPP14 const t_TYPE&& Variant_DataImp<t_TYPE>::value()
const&&
{
    return std::move(d_buffer.object());
}
#else   // BSL_VARIANT_FULL_IMPLEMENTATION
template <class t_TYPE>
inline
const t_TYPE& Variant_DataImp<t_TYPE>::value() const
{
    return d_buffer.object();
}
#endif  // BSL_VARIANT_FULL_IMPLEMENTATION
 
/// This component-private function swaps the values of the specified `lhs`
/// and `rhs` when the type (template parameter) `t_VARIANT` is an
/// allocator-aware variant.
template <class t_VARIANT>
void variant_swapImpl(bsl::true_type, t_VARIANT& lhs, t_VARIANT& rhs)
{
    if (lhs.get_allocator() == rhs.get_allocator()) {
        lhs.swap(rhs);
        return;                                                       // RETURN
    }
 
    t_VARIANT futureLhs(bsl::allocator_arg, lhs.get_allocator(), rhs);
    t_VARIANT futureRhs(bsl::allocator_arg, rhs.get_allocator(), lhs);
 
    futureLhs.swap(lhs);
    futureRhs.swap(rhs);
}
 
/// This component-private function swaps the values of the specified `lhs`
/// and `rhs` when the type (template parameter) `t_VARIANT` is a
/// non-allocator-aware variant.
template <class t_VARIANT>
void variant_swapImpl(bsl::false_type, t_VARIANT& lhs, t_VARIANT& rhs)
{
    lhs.swap(rhs);
}
 
                            // -------------------
                            // struct Variant_Base
                            // -------------------
 
// CREATORS
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
template <class t_HEAD, class... t_TAIL>
inline
Variant_Base<t_HEAD, t_TAIL...>::Variant_Base()
: AllocBase()
, d_type(0)
, d_union(bsl::in_place_index_t<0>(), AllocBase::mechanism())
{
}
 
template <class t_HEAD, class... t_TAIL>
inline
Variant_Base<t_HEAD, t_TAIL...>::Variant_Base(const Variant_Base& original)
: AllocBase()
, d_type(bsl::variant_npos)
{
    if (original.d_type != bsl::variant_npos) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(
            void, copyConstructor, static_cast<const Variant&>(original));
    }
}
 
template <class t_HEAD, class... t_TAIL>
inline
Variant_Base<t_HEAD, t_TAIL...>::Variant_Base(Variant_Base&& original)
: AllocBase(original)
, d_type(bsl::variant_npos)
{
    if (original.d_type != bsl::variant_npos) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(
            void, moveConstructor, static_cast<Variant&>(original));
    }
}
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
template <class t_HEAD, class... t_TAIL>
Variant_Base<t_HEAD, t_TAIL...>::Variant_Base(Variant_ConstructFromStdTag,
                                              size_t index)
: AllocBase()
, d_type(index)
{
}
#endif  // BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
 
template <class t_HEAD, class... t_TAIL>
inline
Variant_Base<t_HEAD, t_TAIL...>::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator)
: AllocBase(allocator)
, d_type(0)
, d_union(bsl::in_place_index_t<0>(), AllocBase::mechanism())
{
}
 
template <class t_HEAD, class... t_TAIL>
inline
Variant_Base<t_HEAD, t_TAIL...>::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator,
                                              const Variant&       original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    if (original.index() != bsl::variant_npos) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
    }
}
 
template <class t_HEAD, class... t_TAIL>
inline
Variant_Base<t_HEAD, t_TAIL...>::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator,
                                              Variant&&            original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    if (original.index() != bsl::variant_npos) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, original);
    }
}
 
#ifdef BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
template <class t_HEAD, class... t_TAIL>
Variant_Base<t_HEAD, t_TAIL...>::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              Variant_ConstructFromStdTag,
                                              size_t         index)
: AllocBase(allocator)
, d_type(index)
{
}
#endif  // BSLS_LIBRARYFEATURES_HAS_CPP17_BASELINE_LIBRARY
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX, class... t_ARGS>
inline
Variant_Base<t_HEAD, t_TAIL...>::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              t_ARGS&&... args)
: d_type(t_INDEX)
, d_union(bsl::in_place_index_t<t_INDEX>(),
          AllocBase::mechanism(),
          std::forward<t_ARGS>(args)...)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX, class... t_ARGS>
inline
Variant_Base<t_HEAD, t_TAIL...>::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              t_ARGS&&... args)
: AllocBase(allocator)
, d_type(t_INDEX)
, d_union(bsl::in_place_index_t<t_INDEX>(),
          AllocBase::mechanism(),
          std::forward<t_ARGS>(args)...)
{
}
#else  // BSL_VARIANT_FULL_IMPLEMENTATION
#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
// {{{ BEGIN GENERATED CODE
// Command line: sim_cpp11_features.pl bslstl_variant.h
#ifndef BSLSTL_VARIANT_VARIADIC_LIMIT
#define BSLSTL_VARIANT_VARIADIC_LIMIT 18
#endif
#ifndef BSLSTL_VARIANT_VARIADIC_LIMIT_L
#define BSLSTL_VARIANT_VARIADIC_LIMIT_L BSLSTL_VARIANT_VARIADIC_LIMIT
#endif
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
template <class t_HEAD>
inline
Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::Variant_Base()
: AllocBase()
, d_type(0)
{
    typedef typename bsl::remove_cv<t_HEAD>::type Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
template <class t_HEAD, class t_TAIL_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     BSLS_COMPILERFEATURES_FILLT(17)>::Variant_Base()
: AllocBase()
, d_type(0)
{
    typedef typename bsl::remove_cv<t_HEAD>::type Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     BSLS_COMPILERFEATURES_FILLT(16)>::Variant_Base()
: AllocBase()
, d_type(0)
{
    typedef typename bsl::remove_cv<t_HEAD>::type Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     BSLS_COMPILERFEATURES_FILLT(15)>::Variant_Base()
: AllocBase()
, d_type(0)
{
    typedef typename bsl::remove_cv<t_HEAD>::type Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     BSLS_COMPILERFEATURES_FILLT(14)>::Variant_Base()
: AllocBase()
, d_type(0)
{
    typedef typename bsl::remove_cv<t_HEAD>::type Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     BSLS_COMPILERFEATURES_FILLT(13)>::Variant_Base()
: AllocBase()
, d_type(0)
{
    typedef typename bsl::remove_cv<t_HEAD>::type Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     BSLS_COMPILERFEATURES_FILLT(12)>::Variant_Base()
: AllocBase()
, d_type(0)
{
    typedef typename bsl::remove_cv<t_HEAD>::type Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     BSLS_COMPILERFEATURES_FILLT(11)>::Variant_Base()
: AllocBase()
, d_type(0)
{
    typedef typename bsl::remove_cv<t_HEAD>::type Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     BSLS_COMPILERFEATURES_FILLT(10)>::Variant_Base()
: AllocBase()
, d_type(0)
{
    typedef typename bsl::remove_cv<t_HEAD>::type Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     BSLS_COMPILERFEATURES_FILLT( 9)>::Variant_Base()
: AllocBase()
, d_type(0)
{
    typedef typename bsl::remove_cv<t_HEAD>::type Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     BSLS_COMPILERFEATURES_FILLT( 8)>::Variant_Base()
: AllocBase()
, d_type(0)
{
    typedef typename bsl::remove_cv<t_HEAD>::type Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     BSLS_COMPILERFEATURES_FILLT( 7)>::Variant_Base()
: AllocBase()
, d_type(0)
{
    typedef typename bsl::remove_cv<t_HEAD>::type Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     BSLS_COMPILERFEATURES_FILLT( 6)>::Variant_Base()
: AllocBase()
, d_type(0)
{
    typedef typename bsl::remove_cv<t_HEAD>::type Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     BSLS_COMPILERFEATURES_FILLT( 5)>::Variant_Base()
: AllocBase()
, d_type(0)
{
    typedef typename bsl::remove_cv<t_HEAD>::type Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     BSLS_COMPILERFEATURES_FILLT( 4)>::Variant_Base()
: AllocBase()
, d_type(0)
{
    typedef typename bsl::remove_cv<t_HEAD>::type Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     BSLS_COMPILERFEATURES_FILLT( 3)>::Variant_Base()
: AllocBase()
, d_type(0)
{
    typedef typename bsl::remove_cv<t_HEAD>::type Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     BSLS_COMPILERFEATURES_FILLT( 2)>::Variant_Base()
: AllocBase()
, d_type(0)
{
    typedef typename bsl::remove_cv<t_HEAD>::type Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     BSLS_COMPILERFEATURES_FILLT( 1)>::Variant_Base()
: AllocBase()
, d_type(0)
{
    typedef typename bsl::remove_cv<t_HEAD>::type Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     t_TAIL_18,
                     BSLS_COMPILERFEATURES_FILLT( 0)>::Variant_Base()
: AllocBase()
, d_type(0)
{
    typedef typename bsl::remove_cv<t_HEAD>::type Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
template <class t_HEAD>
inline
Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                     >::Variant_Base(const Variant& original)
: AllocBase()
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
        d_type = original.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
template <class t_HEAD, class t_TAIL_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     BSLS_COMPILERFEATURES_FILLT(17)
                     >::Variant_Base(const Variant& original)
: AllocBase()
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
        d_type = original.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     BSLS_COMPILERFEATURES_FILLT(16)
                     >::Variant_Base(const Variant& original)
: AllocBase()
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
        d_type = original.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     BSLS_COMPILERFEATURES_FILLT(15)
                     >::Variant_Base(const Variant& original)
: AllocBase()
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
        d_type = original.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     BSLS_COMPILERFEATURES_FILLT(14)
                     >::Variant_Base(const Variant& original)
: AllocBase()
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
        d_type = original.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     BSLS_COMPILERFEATURES_FILLT(13)
                     >::Variant_Base(const Variant& original)
: AllocBase()
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
        d_type = original.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     BSLS_COMPILERFEATURES_FILLT(12)
                     >::Variant_Base(const Variant& original)
: AllocBase()
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
        d_type = original.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     BSLS_COMPILERFEATURES_FILLT(11)
                     >::Variant_Base(const Variant& original)
: AllocBase()
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
        d_type = original.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     BSLS_COMPILERFEATURES_FILLT(10)
                     >::Variant_Base(const Variant& original)
: AllocBase()
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
        d_type = original.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     BSLS_COMPILERFEATURES_FILLT( 9)
                     >::Variant_Base(const Variant& original)
: AllocBase()
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
        d_type = original.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     BSLS_COMPILERFEATURES_FILLT( 8)
                     >::Variant_Base(const Variant& original)
: AllocBase()
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
        d_type = original.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     BSLS_COMPILERFEATURES_FILLT( 7)
                     >::Variant_Base(const Variant& original)
: AllocBase()
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
        d_type = original.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     BSLS_COMPILERFEATURES_FILLT( 6)
                     >::Variant_Base(const Variant& original)
: AllocBase()
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
        d_type = original.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     BSLS_COMPILERFEATURES_FILLT( 5)
                     >::Variant_Base(const Variant& original)
: AllocBase()
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
        d_type = original.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     BSLS_COMPILERFEATURES_FILLT( 4)
                     >::Variant_Base(const Variant& original)
: AllocBase()
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
        d_type = original.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     BSLS_COMPILERFEATURES_FILLT( 3)
                     >::Variant_Base(const Variant& original)
: AllocBase()
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
        d_type = original.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     BSLS_COMPILERFEATURES_FILLT( 2)
                     >::Variant_Base(const Variant& original)
: AllocBase()
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
        d_type = original.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     BSLS_COMPILERFEATURES_FILLT( 1)
                     >::Variant_Base(const Variant& original)
: AllocBase()
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
        d_type = original.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     t_TAIL_18,
                     BSLS_COMPILERFEATURES_FILLT( 0)
                     >::Variant_Base(const Variant& original)
: AllocBase()
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
        d_type = original.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
template <class t_HEAD>
inline
Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::Variant_Base(
                              BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(MoveUtil::access(original))
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
        d_type = lvalue.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
template <class t_HEAD, class t_TAIL_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     BSLS_COMPILERFEATURES_FILLT(17)>::Variant_Base(
                              BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(MoveUtil::access(original))
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
        d_type = lvalue.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     BSLS_COMPILERFEATURES_FILLT(16)>::Variant_Base(
                              BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(MoveUtil::access(original))
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
        d_type = lvalue.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     BSLS_COMPILERFEATURES_FILLT(15)>::Variant_Base(
                              BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(MoveUtil::access(original))
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
        d_type = lvalue.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     BSLS_COMPILERFEATURES_FILLT(14)>::Variant_Base(
                              BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(MoveUtil::access(original))
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
        d_type = lvalue.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     BSLS_COMPILERFEATURES_FILLT(13)>::Variant_Base(
                              BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(MoveUtil::access(original))
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
        d_type = lvalue.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     BSLS_COMPILERFEATURES_FILLT(12)>::Variant_Base(
                              BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(MoveUtil::access(original))
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
        d_type = lvalue.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     BSLS_COMPILERFEATURES_FILLT(11)>::Variant_Base(
                              BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(MoveUtil::access(original))
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
        d_type = lvalue.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     BSLS_COMPILERFEATURES_FILLT(10)>::Variant_Base(
                              BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(MoveUtil::access(original))
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
        d_type = lvalue.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     BSLS_COMPILERFEATURES_FILLT( 9)>::Variant_Base(
                              BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(MoveUtil::access(original))
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
        d_type = lvalue.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     BSLS_COMPILERFEATURES_FILLT( 8)>::Variant_Base(
                              BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(MoveUtil::access(original))
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
        d_type = lvalue.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     BSLS_COMPILERFEATURES_FILLT( 7)>::Variant_Base(
                              BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(MoveUtil::access(original))
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
        d_type = lvalue.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     BSLS_COMPILERFEATURES_FILLT( 6)>::Variant_Base(
                              BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(MoveUtil::access(original))
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
        d_type = lvalue.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     BSLS_COMPILERFEATURES_FILLT( 5)>::Variant_Base(
                              BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(MoveUtil::access(original))
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
        d_type = lvalue.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     BSLS_COMPILERFEATURES_FILLT( 4)>::Variant_Base(
                              BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(MoveUtil::access(original))
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
        d_type = lvalue.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     BSLS_COMPILERFEATURES_FILLT( 3)>::Variant_Base(
                              BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(MoveUtil::access(original))
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
        d_type = lvalue.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     BSLS_COMPILERFEATURES_FILLT( 2)>::Variant_Base(
                              BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(MoveUtil::access(original))
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
        d_type = lvalue.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     BSLS_COMPILERFEATURES_FILLT( 1)>::Variant_Base(
                              BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(MoveUtil::access(original))
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
        d_type = lvalue.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     t_TAIL_18,
                     BSLS_COMPILERFEATURES_FILLT( 0)>::Variant_Base(
                              BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(MoveUtil::access(original))
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
        d_type = lvalue.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
template <class t_HEAD>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     BSLS_COMPILERFEATURES_FILLT(17)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     BSLS_COMPILERFEATURES_FILLT(16)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     BSLS_COMPILERFEATURES_FILLT(15)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     BSLS_COMPILERFEATURES_FILLT(14)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     BSLS_COMPILERFEATURES_FILLT(13)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     BSLS_COMPILERFEATURES_FILLT(12)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     BSLS_COMPILERFEATURES_FILLT(11)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     BSLS_COMPILERFEATURES_FILLT(10)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     BSLS_COMPILERFEATURES_FILLT( 9)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     BSLS_COMPILERFEATURES_FILLT( 8)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     BSLS_COMPILERFEATURES_FILLT( 7)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     BSLS_COMPILERFEATURES_FILLT( 6)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     BSLS_COMPILERFEATURES_FILLT( 5)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     BSLS_COMPILERFEATURES_FILLT( 4)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     BSLS_COMPILERFEATURES_FILLT( 3)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     BSLS_COMPILERFEATURES_FILLT( 2)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     BSLS_COMPILERFEATURES_FILLT( 1)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     t_TAIL_18,
                     BSLS_COMPILERFEATURES_FILLT( 0)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
template <class t_HEAD>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     BSLS_COMPILERFEATURES_FILLT(17)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     BSLS_COMPILERFEATURES_FILLT(16)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     BSLS_COMPILERFEATURES_FILLT(15)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     BSLS_COMPILERFEATURES_FILLT(14)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     BSLS_COMPILERFEATURES_FILLT(13)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     BSLS_COMPILERFEATURES_FILLT(12)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     BSLS_COMPILERFEATURES_FILLT(11)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     BSLS_COMPILERFEATURES_FILLT(10)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     BSLS_COMPILERFEATURES_FILLT( 9)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     BSLS_COMPILERFEATURES_FILLT( 8)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     BSLS_COMPILERFEATURES_FILLT( 7)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     BSLS_COMPILERFEATURES_FILLT( 6)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     BSLS_COMPILERFEATURES_FILLT( 5)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     BSLS_COMPILERFEATURES_FILLT( 4)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     BSLS_COMPILERFEATURES_FILLT( 3)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     BSLS_COMPILERFEATURES_FILLT( 2)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     BSLS_COMPILERFEATURES_FILLT( 1)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     t_TAIL_18,
                     BSLS_COMPILERFEATURES_FILLT( 0)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
template <class t_HEAD>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     BSLS_COMPILERFEATURES_FILLT(17)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     BSLS_COMPILERFEATURES_FILLT(16)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     BSLS_COMPILERFEATURES_FILLT(15)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     BSLS_COMPILERFEATURES_FILLT(14)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     BSLS_COMPILERFEATURES_FILLT(13)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     BSLS_COMPILERFEATURES_FILLT(12)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     BSLS_COMPILERFEATURES_FILLT(11)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     BSLS_COMPILERFEATURES_FILLT(10)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     BSLS_COMPILERFEATURES_FILLT( 9)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     BSLS_COMPILERFEATURES_FILLT( 8)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     BSLS_COMPILERFEATURES_FILLT( 7)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     BSLS_COMPILERFEATURES_FILLT( 6)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     BSLS_COMPILERFEATURES_FILLT( 5)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     BSLS_COMPILERFEATURES_FILLT( 4)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     BSLS_COMPILERFEATURES_FILLT( 3)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     BSLS_COMPILERFEATURES_FILLT( 2)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     BSLS_COMPILERFEATURES_FILLT( 1)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     t_TAIL_18,
                     BSLS_COMPILERFEATURES_FILLT( 0)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
template <class t_HEAD>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02,
                                         const t_ARG_03&                arg_03)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     BSLS_COMPILERFEATURES_FILLT(17)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02,
                                         const t_ARG_03&                arg_03)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     BSLS_COMPILERFEATURES_FILLT(16)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02,
                                         const t_ARG_03&                arg_03)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     BSLS_COMPILERFEATURES_FILLT(15)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02,
                                         const t_ARG_03&                arg_03)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     BSLS_COMPILERFEATURES_FILLT(14)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02,
                                         const t_ARG_03&                arg_03)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     BSLS_COMPILERFEATURES_FILLT(13)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02,
                                         const t_ARG_03&                arg_03)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     BSLS_COMPILERFEATURES_FILLT(12)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02,
                                         const t_ARG_03&                arg_03)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     BSLS_COMPILERFEATURES_FILLT(11)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02,
                                         const t_ARG_03&                arg_03)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     BSLS_COMPILERFEATURES_FILLT(10)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02,
                                         const t_ARG_03&                arg_03)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     BSLS_COMPILERFEATURES_FILLT( 9)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02,
                                         const t_ARG_03&                arg_03)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     BSLS_COMPILERFEATURES_FILLT( 8)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02,
                                         const t_ARG_03&                arg_03)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     BSLS_COMPILERFEATURES_FILLT( 7)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02,
                                         const t_ARG_03&                arg_03)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     BSLS_COMPILERFEATURES_FILLT( 6)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02,
                                         const t_ARG_03&                arg_03)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     BSLS_COMPILERFEATURES_FILLT( 5)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02,
                                         const t_ARG_03&                arg_03)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     BSLS_COMPILERFEATURES_FILLT( 4)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02,
                                         const t_ARG_03&                arg_03)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     BSLS_COMPILERFEATURES_FILLT( 3)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02,
                                         const t_ARG_03&                arg_03)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     BSLS_COMPILERFEATURES_FILLT( 2)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02,
                                         const t_ARG_03&                arg_03)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     BSLS_COMPILERFEATURES_FILLT( 1)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02,
                                         const t_ARG_03&                arg_03)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     t_TAIL_18,
                     BSLS_COMPILERFEATURES_FILLT( 0)>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02,
                                         const t_ARG_03&                arg_03)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     BSLS_COMPILERFEATURES_FILLT(17)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     BSLS_COMPILERFEATURES_FILLT(16)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     BSLS_COMPILERFEATURES_FILLT(15)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     BSLS_COMPILERFEATURES_FILLT(14)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     BSLS_COMPILERFEATURES_FILLT(13)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     BSLS_COMPILERFEATURES_FILLT(12)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     BSLS_COMPILERFEATURES_FILLT(11)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     BSLS_COMPILERFEATURES_FILLT(10)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     BSLS_COMPILERFEATURES_FILLT( 9)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     BSLS_COMPILERFEATURES_FILLT( 8)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     BSLS_COMPILERFEATURES_FILLT( 7)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     BSLS_COMPILERFEATURES_FILLT( 6)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     BSLS_COMPILERFEATURES_FILLT( 5)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     BSLS_COMPILERFEATURES_FILLT( 4)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     BSLS_COMPILERFEATURES_FILLT( 3)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     BSLS_COMPILERFEATURES_FILLT( 2)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     BSLS_COMPILERFEATURES_FILLT( 1)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     t_TAIL_18,
                     BSLS_COMPILERFEATURES_FILLT( 0)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     BSLS_COMPILERFEATURES_FILLT(17)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     BSLS_COMPILERFEATURES_FILLT(16)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     BSLS_COMPILERFEATURES_FILLT(15)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     BSLS_COMPILERFEATURES_FILLT(14)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     BSLS_COMPILERFEATURES_FILLT(13)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     BSLS_COMPILERFEATURES_FILLT(12)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     BSLS_COMPILERFEATURES_FILLT(11)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     BSLS_COMPILERFEATURES_FILLT(10)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     BSLS_COMPILERFEATURES_FILLT( 9)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     BSLS_COMPILERFEATURES_FILLT( 8)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     BSLS_COMPILERFEATURES_FILLT( 7)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     BSLS_COMPILERFEATURES_FILLT( 6)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     BSLS_COMPILERFEATURES_FILLT( 5)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     BSLS_COMPILERFEATURES_FILLT( 4)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     BSLS_COMPILERFEATURES_FILLT( 3)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     BSLS_COMPILERFEATURES_FILLT( 2)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     BSLS_COMPILERFEATURES_FILLT( 1)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     t_TAIL_18,
                     BSLS_COMPILERFEATURES_FILLT( 0)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     BSLS_COMPILERFEATURES_FILLT(17)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     BSLS_COMPILERFEATURES_FILLT(16)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     BSLS_COMPILERFEATURES_FILLT(15)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     BSLS_COMPILERFEATURES_FILLT(14)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     BSLS_COMPILERFEATURES_FILLT(13)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     BSLS_COMPILERFEATURES_FILLT(12)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     BSLS_COMPILERFEATURES_FILLT(11)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     BSLS_COMPILERFEATURES_FILLT(10)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     BSLS_COMPILERFEATURES_FILLT( 9)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     BSLS_COMPILERFEATURES_FILLT( 8)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     BSLS_COMPILERFEATURES_FILLT( 7)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     BSLS_COMPILERFEATURES_FILLT( 6)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     BSLS_COMPILERFEATURES_FILLT( 5)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     BSLS_COMPILERFEATURES_FILLT( 4)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     BSLS_COMPILERFEATURES_FILLT( 3)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     BSLS_COMPILERFEATURES_FILLT( 2)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     BSLS_COMPILERFEATURES_FILLT( 1)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     t_TAIL_18,
                     BSLS_COMPILERFEATURES_FILLT( 0)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     BSLS_COMPILERFEATURES_FILLT(17)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     BSLS_COMPILERFEATURES_FILLT(16)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     BSLS_COMPILERFEATURES_FILLT(15)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     BSLS_COMPILERFEATURES_FILLT(14)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     BSLS_COMPILERFEATURES_FILLT(13)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     BSLS_COMPILERFEATURES_FILLT(12)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     BSLS_COMPILERFEATURES_FILLT(11)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     BSLS_COMPILERFEATURES_FILLT(10)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     BSLS_COMPILERFEATURES_FILLT( 9)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     BSLS_COMPILERFEATURES_FILLT( 8)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     BSLS_COMPILERFEATURES_FILLT( 7)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     BSLS_COMPILERFEATURES_FILLT( 6)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     BSLS_COMPILERFEATURES_FILLT( 5)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     BSLS_COMPILERFEATURES_FILLT( 4)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     BSLS_COMPILERFEATURES_FILLT( 3)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     BSLS_COMPILERFEATURES_FILLT( 2)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     BSLS_COMPILERFEATURES_FILLT( 1)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     t_TAIL_18,
                     BSLS_COMPILERFEATURES_FILLT( 0)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     BSLS_COMPILERFEATURES_FILLT(17)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     BSLS_COMPILERFEATURES_FILLT(16)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     BSLS_COMPILERFEATURES_FILLT(15)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     BSLS_COMPILERFEATURES_FILLT(14)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     BSLS_COMPILERFEATURES_FILLT(13)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     BSLS_COMPILERFEATURES_FILLT(12)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     BSLS_COMPILERFEATURES_FILLT(11)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     BSLS_COMPILERFEATURES_FILLT(10)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     BSLS_COMPILERFEATURES_FILLT( 9)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     BSLS_COMPILERFEATURES_FILLT( 8)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     BSLS_COMPILERFEATURES_FILLT( 7)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     BSLS_COMPILERFEATURES_FILLT( 6)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     BSLS_COMPILERFEATURES_FILLT( 5)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     BSLS_COMPILERFEATURES_FILLT( 4)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     BSLS_COMPILERFEATURES_FILLT( 3)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     BSLS_COMPILERFEATURES_FILLT( 2)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     BSLS_COMPILERFEATURES_FILLT( 1)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     t_TAIL_18,
                     BSLS_COMPILERFEATURES_FILLT( 0)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     BSLS_COMPILERFEATURES_FILLT(17)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     BSLS_COMPILERFEATURES_FILLT(16)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     BSLS_COMPILERFEATURES_FILLT(15)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     BSLS_COMPILERFEATURES_FILLT(14)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     BSLS_COMPILERFEATURES_FILLT(13)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     BSLS_COMPILERFEATURES_FILLT(12)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     BSLS_COMPILERFEATURES_FILLT(11)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     BSLS_COMPILERFEATURES_FILLT(10)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     BSLS_COMPILERFEATURES_FILLT( 9)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     BSLS_COMPILERFEATURES_FILLT( 8)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     BSLS_COMPILERFEATURES_FILLT( 7)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     BSLS_COMPILERFEATURES_FILLT( 6)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     BSLS_COMPILERFEATURES_FILLT( 5)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     BSLS_COMPILERFEATURES_FILLT( 4)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     BSLS_COMPILERFEATURES_FILLT( 3)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     BSLS_COMPILERFEATURES_FILLT( 2)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     BSLS_COMPILERFEATURES_FILLT( 1)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     t_TAIL_18,
                     BSLS_COMPILERFEATURES_FILLT( 0)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     BSLS_COMPILERFEATURES_FILLT(17)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     BSLS_COMPILERFEATURES_FILLT(16)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     BSLS_COMPILERFEATURES_FILLT(15)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     BSLS_COMPILERFEATURES_FILLT(14)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     BSLS_COMPILERFEATURES_FILLT(13)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     BSLS_COMPILERFEATURES_FILLT(12)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     BSLS_COMPILERFEATURES_FILLT(11)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     BSLS_COMPILERFEATURES_FILLT(10)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     BSLS_COMPILERFEATURES_FILLT( 9)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     BSLS_COMPILERFEATURES_FILLT( 8)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     BSLS_COMPILERFEATURES_FILLT( 7)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     BSLS_COMPILERFEATURES_FILLT( 6)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     BSLS_COMPILERFEATURES_FILLT( 5)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     BSLS_COMPILERFEATURES_FILLT( 4)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     BSLS_COMPILERFEATURES_FILLT( 3)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     BSLS_COMPILERFEATURES_FILLT( 2)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     BSLS_COMPILERFEATURES_FILLT( 1)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     t_TAIL_18,
                     BSLS_COMPILERFEATURES_FILLT( 0)
                     >::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
template <class t_HEAD>
inline
Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator)
: AllocBase(allocator)
, d_type(0)
{
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<t_HEAD *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
template <class t_HEAD, class t_TAIL_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     BSLS_COMPILERFEATURES_FILLT(17)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator)
: AllocBase(allocator)
, d_type(0)
{
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<t_HEAD *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     BSLS_COMPILERFEATURES_FILLT(16)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator)
: AllocBase(allocator)
, d_type(0)
{
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<t_HEAD *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     BSLS_COMPILERFEATURES_FILLT(15)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator)
: AllocBase(allocator)
, d_type(0)
{
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<t_HEAD *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     BSLS_COMPILERFEATURES_FILLT(14)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator)
: AllocBase(allocator)
, d_type(0)
{
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<t_HEAD *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     BSLS_COMPILERFEATURES_FILLT(13)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator)
: AllocBase(allocator)
, d_type(0)
{
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<t_HEAD *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     BSLS_COMPILERFEATURES_FILLT(12)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator)
: AllocBase(allocator)
, d_type(0)
{
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<t_HEAD *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     BSLS_COMPILERFEATURES_FILLT(11)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator)
: AllocBase(allocator)
, d_type(0)
{
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<t_HEAD *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     BSLS_COMPILERFEATURES_FILLT(10)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator)
: AllocBase(allocator)
, d_type(0)
{
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<t_HEAD *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     BSLS_COMPILERFEATURES_FILLT( 9)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator)
: AllocBase(allocator)
, d_type(0)
{
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<t_HEAD *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     BSLS_COMPILERFEATURES_FILLT( 8)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator)
: AllocBase(allocator)
, d_type(0)
{
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<t_HEAD *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     BSLS_COMPILERFEATURES_FILLT( 7)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator)
: AllocBase(allocator)
, d_type(0)
{
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<t_HEAD *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     BSLS_COMPILERFEATURES_FILLT( 6)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator)
: AllocBase(allocator)
, d_type(0)
{
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<t_HEAD *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     BSLS_COMPILERFEATURES_FILLT( 5)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator)
: AllocBase(allocator)
, d_type(0)
{
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<t_HEAD *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     BSLS_COMPILERFEATURES_FILLT( 4)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator)
: AllocBase(allocator)
, d_type(0)
{
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<t_HEAD *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     BSLS_COMPILERFEATURES_FILLT( 3)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator)
: AllocBase(allocator)
, d_type(0)
{
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<t_HEAD *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     BSLS_COMPILERFEATURES_FILLT( 2)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator)
: AllocBase(allocator)
, d_type(0)
{
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<t_HEAD *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     BSLS_COMPILERFEATURES_FILLT( 1)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator)
: AllocBase(allocator)
, d_type(0)
{
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<t_HEAD *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     t_TAIL_18,
                     BSLS_COMPILERFEATURES_FILLT( 0)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator)
: AllocBase(allocator)
, d_type(0)
{
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<t_HEAD *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
template <class t_HEAD>
inline
Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator,
                                              const Variant&       original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
 
        d_type = original.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
template <class t_HEAD, class t_TAIL_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     BSLS_COMPILERFEATURES_FILLT(17)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator,
                                              const Variant&       original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
 
        d_type = original.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     BSLS_COMPILERFEATURES_FILLT(16)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator,
                                              const Variant&       original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
 
        d_type = original.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     BSLS_COMPILERFEATURES_FILLT(15)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator,
                                              const Variant&       original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
 
        d_type = original.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     BSLS_COMPILERFEATURES_FILLT(14)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator,
                                              const Variant&       original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
 
        d_type = original.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     BSLS_COMPILERFEATURES_FILLT(13)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator,
                                              const Variant&       original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
 
        d_type = original.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     BSLS_COMPILERFEATURES_FILLT(12)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator,
                                              const Variant&       original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
 
        d_type = original.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     BSLS_COMPILERFEATURES_FILLT(11)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator,
                                              const Variant&       original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
 
        d_type = original.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     BSLS_COMPILERFEATURES_FILLT(10)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator,
                                              const Variant&       original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
 
        d_type = original.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     BSLS_COMPILERFEATURES_FILLT( 9)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator,
                                              const Variant&       original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
 
        d_type = original.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     BSLS_COMPILERFEATURES_FILLT( 8)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator,
                                              const Variant&       original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
 
        d_type = original.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     BSLS_COMPILERFEATURES_FILLT( 7)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator,
                                              const Variant&       original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
 
        d_type = original.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     BSLS_COMPILERFEATURES_FILLT( 6)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator,
                                              const Variant&       original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
 
        d_type = original.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     BSLS_COMPILERFEATURES_FILLT( 5)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator,
                                              const Variant&       original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
 
        d_type = original.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     BSLS_COMPILERFEATURES_FILLT( 4)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator,
                                              const Variant&       original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
 
        d_type = original.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     BSLS_COMPILERFEATURES_FILLT( 3)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator,
                                              const Variant&       original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
 
        d_type = original.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     BSLS_COMPILERFEATURES_FILLT( 2)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator,
                                              const Variant&       original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
 
        d_type = original.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     BSLS_COMPILERFEATURES_FILLT( 1)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator,
                                              const Variant&       original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
 
        d_type = original.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     t_TAIL_18,
                     BSLS_COMPILERFEATURES_FILLT( 0)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator,
                                              const Variant&       original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
 
        d_type = original.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
template <class t_HEAD>
inline
Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::Variant_Base(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
 
        d_type = lvalue.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
template <class t_HEAD, class t_TAIL_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     BSLS_COMPILERFEATURES_FILLT(17)>::Variant_Base(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
 
        d_type = lvalue.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     BSLS_COMPILERFEATURES_FILLT(16)>::Variant_Base(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
 
        d_type = lvalue.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     BSLS_COMPILERFEATURES_FILLT(15)>::Variant_Base(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
 
        d_type = lvalue.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     BSLS_COMPILERFEATURES_FILLT(14)>::Variant_Base(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
 
        d_type = lvalue.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     BSLS_COMPILERFEATURES_FILLT(13)>::Variant_Base(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
 
        d_type = lvalue.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     BSLS_COMPILERFEATURES_FILLT(12)>::Variant_Base(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
 
        d_type = lvalue.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     BSLS_COMPILERFEATURES_FILLT(11)>::Variant_Base(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
 
        d_type = lvalue.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     BSLS_COMPILERFEATURES_FILLT(10)>::Variant_Base(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
 
        d_type = lvalue.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     BSLS_COMPILERFEATURES_FILLT( 9)>::Variant_Base(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
 
        d_type = lvalue.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     BSLS_COMPILERFEATURES_FILLT( 8)>::Variant_Base(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
 
        d_type = lvalue.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     BSLS_COMPILERFEATURES_FILLT( 7)>::Variant_Base(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
 
        d_type = lvalue.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     BSLS_COMPILERFEATURES_FILLT( 6)>::Variant_Base(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
 
        d_type = lvalue.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     BSLS_COMPILERFEATURES_FILLT( 5)>::Variant_Base(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
 
        d_type = lvalue.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     BSLS_COMPILERFEATURES_FILLT( 4)>::Variant_Base(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
 
        d_type = lvalue.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     BSLS_COMPILERFEATURES_FILLT( 3)>::Variant_Base(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
 
        d_type = lvalue.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     BSLS_COMPILERFEATURES_FILLT( 2)>::Variant_Base(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
 
        d_type = lvalue.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     BSLS_COMPILERFEATURES_FILLT( 1)>::Variant_Base(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
 
        d_type = lvalue.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     t_TAIL_18,
                     BSLS_COMPILERFEATURES_FILLT( 0)>::Variant_Base(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
 
        d_type = lvalue.d_type;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
template <class t_HEAD>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     BSLS_COMPILERFEATURES_FILLT(17)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     BSLS_COMPILERFEATURES_FILLT(16)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     BSLS_COMPILERFEATURES_FILLT(15)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     BSLS_COMPILERFEATURES_FILLT(14)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     BSLS_COMPILERFEATURES_FILLT(13)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     BSLS_COMPILERFEATURES_FILLT(12)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     BSLS_COMPILERFEATURES_FILLT(11)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     BSLS_COMPILERFEATURES_FILLT(10)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     BSLS_COMPILERFEATURES_FILLT( 9)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     BSLS_COMPILERFEATURES_FILLT( 8)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     BSLS_COMPILERFEATURES_FILLT( 7)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     BSLS_COMPILERFEATURES_FILLT( 6)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     BSLS_COMPILERFEATURES_FILLT( 5)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     BSLS_COMPILERFEATURES_FILLT( 4)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     BSLS_COMPILERFEATURES_FILLT( 3)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     BSLS_COMPILERFEATURES_FILLT( 2)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     BSLS_COMPILERFEATURES_FILLT( 1)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     t_TAIL_18,
                     BSLS_COMPILERFEATURES_FILLT( 0)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
template <class t_HEAD>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     BSLS_COMPILERFEATURES_FILLT(17)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     BSLS_COMPILERFEATURES_FILLT(16)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     BSLS_COMPILERFEATURES_FILLT(15)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     BSLS_COMPILERFEATURES_FILLT(14)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     BSLS_COMPILERFEATURES_FILLT(13)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     BSLS_COMPILERFEATURES_FILLT(12)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     BSLS_COMPILERFEATURES_FILLT(11)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     BSLS_COMPILERFEATURES_FILLT(10)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     BSLS_COMPILERFEATURES_FILLT( 9)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     BSLS_COMPILERFEATURES_FILLT( 8)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     BSLS_COMPILERFEATURES_FILLT( 7)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     BSLS_COMPILERFEATURES_FILLT( 6)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     BSLS_COMPILERFEATURES_FILLT( 5)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     BSLS_COMPILERFEATURES_FILLT( 4)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     BSLS_COMPILERFEATURES_FILLT( 3)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     BSLS_COMPILERFEATURES_FILLT( 2)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     BSLS_COMPILERFEATURES_FILLT( 1)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     t_TAIL_18,
                     BSLS_COMPILERFEATURES_FILLT( 0)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
template <class t_HEAD>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     BSLS_COMPILERFEATURES_FILLT(17)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     BSLS_COMPILERFEATURES_FILLT(16)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     BSLS_COMPILERFEATURES_FILLT(15)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     BSLS_COMPILERFEATURES_FILLT(14)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     BSLS_COMPILERFEATURES_FILLT(13)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     BSLS_COMPILERFEATURES_FILLT(12)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     BSLS_COMPILERFEATURES_FILLT(11)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     BSLS_COMPILERFEATURES_FILLT(10)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     BSLS_COMPILERFEATURES_FILLT( 9)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     BSLS_COMPILERFEATURES_FILLT( 8)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     BSLS_COMPILERFEATURES_FILLT( 7)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     BSLS_COMPILERFEATURES_FILLT( 6)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     BSLS_COMPILERFEATURES_FILLT( 5)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     BSLS_COMPILERFEATURES_FILLT( 4)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     BSLS_COMPILERFEATURES_FILLT( 3)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     BSLS_COMPILERFEATURES_FILLT( 2)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     BSLS_COMPILERFEATURES_FILLT( 1)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     t_TAIL_18,
                     BSLS_COMPILERFEATURES_FILLT( 0)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
template <class t_HEAD>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02,
                                      const t_ARG_03&                arg_03)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     BSLS_COMPILERFEATURES_FILLT(17)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02,
                                      const t_ARG_03&                arg_03)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     BSLS_COMPILERFEATURES_FILLT(16)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02,
                                      const t_ARG_03&                arg_03)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     BSLS_COMPILERFEATURES_FILLT(15)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02,
                                      const t_ARG_03&                arg_03)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     BSLS_COMPILERFEATURES_FILLT(14)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02,
                                      const t_ARG_03&                arg_03)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     BSLS_COMPILERFEATURES_FILLT(13)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02,
                                      const t_ARG_03&                arg_03)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     BSLS_COMPILERFEATURES_FILLT(12)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02,
                                      const t_ARG_03&                arg_03)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     BSLS_COMPILERFEATURES_FILLT(11)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02,
                                      const t_ARG_03&                arg_03)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     BSLS_COMPILERFEATURES_FILLT(10)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02,
                                      const t_ARG_03&                arg_03)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     BSLS_COMPILERFEATURES_FILLT( 9)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02,
                                      const t_ARG_03&                arg_03)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     BSLS_COMPILERFEATURES_FILLT( 8)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02,
                                      const t_ARG_03&                arg_03)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     BSLS_COMPILERFEATURES_FILLT( 7)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02,
                                      const t_ARG_03&                arg_03)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     BSLS_COMPILERFEATURES_FILLT( 6)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02,
                                      const t_ARG_03&                arg_03)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     BSLS_COMPILERFEATURES_FILLT( 5)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02,
                                      const t_ARG_03&                arg_03)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     BSLS_COMPILERFEATURES_FILLT( 4)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02,
                                      const t_ARG_03&                arg_03)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     BSLS_COMPILERFEATURES_FILLT( 3)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02,
                                      const t_ARG_03&                arg_03)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     BSLS_COMPILERFEATURES_FILLT( 2)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02,
                                      const t_ARG_03&                arg_03)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     BSLS_COMPILERFEATURES_FILLT( 1)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02,
                                      const t_ARG_03&                arg_03)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     t_TAIL_18,
                     BSLS_COMPILERFEATURES_FILLT( 0)>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02,
                                      const t_ARG_03&                arg_03)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     BSLS_COMPILERFEATURES_FILLT(17)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     BSLS_COMPILERFEATURES_FILLT(16)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     BSLS_COMPILERFEATURES_FILLT(15)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     BSLS_COMPILERFEATURES_FILLT(14)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     BSLS_COMPILERFEATURES_FILLT(13)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     BSLS_COMPILERFEATURES_FILLT(12)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     BSLS_COMPILERFEATURES_FILLT(11)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     BSLS_COMPILERFEATURES_FILLT(10)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     BSLS_COMPILERFEATURES_FILLT( 9)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     BSLS_COMPILERFEATURES_FILLT( 8)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     BSLS_COMPILERFEATURES_FILLT( 7)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     BSLS_COMPILERFEATURES_FILLT( 6)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     BSLS_COMPILERFEATURES_FILLT( 5)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     BSLS_COMPILERFEATURES_FILLT( 4)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     BSLS_COMPILERFEATURES_FILLT( 3)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     BSLS_COMPILERFEATURES_FILLT( 2)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     BSLS_COMPILERFEATURES_FILLT( 1)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     t_TAIL_18,
                     BSLS_COMPILERFEATURES_FILLT( 0)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     BSLS_COMPILERFEATURES_FILLT(17)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     BSLS_COMPILERFEATURES_FILLT(16)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     BSLS_COMPILERFEATURES_FILLT(15)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     BSLS_COMPILERFEATURES_FILLT(14)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     BSLS_COMPILERFEATURES_FILLT(13)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     BSLS_COMPILERFEATURES_FILLT(12)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     BSLS_COMPILERFEATURES_FILLT(11)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     BSLS_COMPILERFEATURES_FILLT(10)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     BSLS_COMPILERFEATURES_FILLT( 9)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     BSLS_COMPILERFEATURES_FILLT( 8)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     BSLS_COMPILERFEATURES_FILLT( 7)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     BSLS_COMPILERFEATURES_FILLT( 6)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     BSLS_COMPILERFEATURES_FILLT( 5)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     BSLS_COMPILERFEATURES_FILLT( 4)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     BSLS_COMPILERFEATURES_FILLT( 3)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     BSLS_COMPILERFEATURES_FILLT( 2)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     BSLS_COMPILERFEATURES_FILLT( 1)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     t_TAIL_18,
                     BSLS_COMPILERFEATURES_FILLT( 0)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     BSLS_COMPILERFEATURES_FILLT(17)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     BSLS_COMPILERFEATURES_FILLT(16)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     BSLS_COMPILERFEATURES_FILLT(15)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     BSLS_COMPILERFEATURES_FILLT(14)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     BSLS_COMPILERFEATURES_FILLT(13)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     BSLS_COMPILERFEATURES_FILLT(12)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     BSLS_COMPILERFEATURES_FILLT(11)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     BSLS_COMPILERFEATURES_FILLT(10)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     BSLS_COMPILERFEATURES_FILLT( 9)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     BSLS_COMPILERFEATURES_FILLT( 8)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     BSLS_COMPILERFEATURES_FILLT( 7)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     BSLS_COMPILERFEATURES_FILLT( 6)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     BSLS_COMPILERFEATURES_FILLT( 5)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     BSLS_COMPILERFEATURES_FILLT( 4)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     BSLS_COMPILERFEATURES_FILLT( 3)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     BSLS_COMPILERFEATURES_FILLT( 2)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     BSLS_COMPILERFEATURES_FILLT( 1)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     t_TAIL_18,
                     BSLS_COMPILERFEATURES_FILLT( 0)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     BSLS_COMPILERFEATURES_FILLT(17)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     BSLS_COMPILERFEATURES_FILLT(16)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     BSLS_COMPILERFEATURES_FILLT(15)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     BSLS_COMPILERFEATURES_FILLT(14)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     BSLS_COMPILERFEATURES_FILLT(13)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     BSLS_COMPILERFEATURES_FILLT(12)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     BSLS_COMPILERFEATURES_FILLT(11)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     BSLS_COMPILERFEATURES_FILLT(10)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     BSLS_COMPILERFEATURES_FILLT( 9)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     BSLS_COMPILERFEATURES_FILLT( 8)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     BSLS_COMPILERFEATURES_FILLT( 7)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     BSLS_COMPILERFEATURES_FILLT( 6)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     BSLS_COMPILERFEATURES_FILLT( 5)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     BSLS_COMPILERFEATURES_FILLT( 4)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     BSLS_COMPILERFEATURES_FILLT( 3)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     BSLS_COMPILERFEATURES_FILLT( 2)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     BSLS_COMPILERFEATURES_FILLT( 1)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     t_TAIL_18,
                     BSLS_COMPILERFEATURES_FILLT( 0)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     BSLS_COMPILERFEATURES_FILLT(17)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     BSLS_COMPILERFEATURES_FILLT(16)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     BSLS_COMPILERFEATURES_FILLT(15)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     BSLS_COMPILERFEATURES_FILLT(14)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     BSLS_COMPILERFEATURES_FILLT(13)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     BSLS_COMPILERFEATURES_FILLT(12)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     BSLS_COMPILERFEATURES_FILLT(11)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     BSLS_COMPILERFEATURES_FILLT(10)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     BSLS_COMPILERFEATURES_FILLT( 9)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     BSLS_COMPILERFEATURES_FILLT( 8)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     BSLS_COMPILERFEATURES_FILLT( 7)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     BSLS_COMPILERFEATURES_FILLT( 6)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     BSLS_COMPILERFEATURES_FILLT( 5)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     BSLS_COMPILERFEATURES_FILLT( 4)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     BSLS_COMPILERFEATURES_FILLT( 3)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     BSLS_COMPILERFEATURES_FILLT( 2)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     BSLS_COMPILERFEATURES_FILLT( 1)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     t_TAIL_18,
                     BSLS_COMPILERFEATURES_FILLT( 0)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     BSLS_COMPILERFEATURES_FILLT(17)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     BSLS_COMPILERFEATURES_FILLT(16)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     BSLS_COMPILERFEATURES_FILLT(15)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     BSLS_COMPILERFEATURES_FILLT(14)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     BSLS_COMPILERFEATURES_FILLT(13)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     BSLS_COMPILERFEATURES_FILLT(12)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     BSLS_COMPILERFEATURES_FILLT(11)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     BSLS_COMPILERFEATURES_FILLT(10)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     BSLS_COMPILERFEATURES_FILLT( 9)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     BSLS_COMPILERFEATURES_FILLT( 8)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     BSLS_COMPILERFEATURES_FILLT( 7)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     BSLS_COMPILERFEATURES_FILLT( 6)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     BSLS_COMPILERFEATURES_FILLT( 5)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     BSLS_COMPILERFEATURES_FILLT( 4)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     BSLS_COMPILERFEATURES_FILLT( 3)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     BSLS_COMPILERFEATURES_FILLT( 2)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     BSLS_COMPILERFEATURES_FILLT( 1)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     t_TAIL_18,
                     BSLS_COMPILERFEATURES_FILLT( 0)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     BSLS_COMPILERFEATURES_FILLT(17)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     BSLS_COMPILERFEATURES_FILLT(16)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     BSLS_COMPILERFEATURES_FILLT(15)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     BSLS_COMPILERFEATURES_FILLT(14)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     BSLS_COMPILERFEATURES_FILLT(13)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     BSLS_COMPILERFEATURES_FILLT(12)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     BSLS_COMPILERFEATURES_FILLT(11)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     BSLS_COMPILERFEATURES_FILLT(10)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     BSLS_COMPILERFEATURES_FILLT( 9)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     BSLS_COMPILERFEATURES_FILLT( 8)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     BSLS_COMPILERFEATURES_FILLT( 7)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     BSLS_COMPILERFEATURES_FILLT( 6)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     BSLS_COMPILERFEATURES_FILLT( 5)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     BSLS_COMPILERFEATURES_FILLT( 4)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     BSLS_COMPILERFEATURES_FILLT( 3)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     BSLS_COMPILERFEATURES_FILLT( 2)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     BSLS_COMPILERFEATURES_FILLT( 1)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     t_TAIL_18,
                     BSLS_COMPILERFEATURES_FILLT( 0)
                     >::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 18
 
#else
// The generated code below is a workaround for the absence of perfect
// forwarding in some compilers.
template <class t_HEAD, class... t_TAIL>
inline
Variant_Base<t_HEAD, t_TAIL...>::Variant_Base()
: AllocBase()
, d_type(0)
{
    typedef typename bsl::remove_cv<t_HEAD>::type Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
 
template <class t_HEAD, class... t_TAIL>
inline
Variant_Base<t_HEAD, t_TAIL...>::Variant_Base(const Variant& original)
: AllocBase()
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
        d_type = original.d_type;
    }
}
 
template <class t_HEAD, class... t_TAIL>
inline
Variant_Base<t_HEAD, t_TAIL...>::Variant_Base(
                              BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(MoveUtil::access(original))
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
        d_type = lvalue.d_type;
    }
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, t_TAIL...>::Variant_Base(bsl::in_place_index_t<t_INDEX>)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, t_TAIL...>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, t_TAIL...>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, t_TAIL...>::Variant_Base(
                                         bsl::in_place_index_t<t_INDEX>,
                                         const t_ARG_01&                arg_01,
                                         const t_ARG_02&                arg_02,
                                         const t_ARG_03&                arg_03)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, t_TAIL...>::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, t_TAIL...>::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, t_TAIL...>::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, t_TAIL...>::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, t_TAIL...>::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, t_TAIL...>::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, t_TAIL...>::Variant_Base(bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase()
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
 
template <class t_HEAD, class... t_TAIL>
inline
Variant_Base<t_HEAD, t_TAIL...>::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator)
: AllocBase(allocator)
, d_type(0)
{
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<t_HEAD *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
 
template <class t_HEAD, class... t_TAIL>
inline
Variant_Base<t_HEAD, t_TAIL...>::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type       allocator,
                                              const Variant&       original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    if (!original.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
            copyConstructor(this);
        BSLSTL_VARIANT_VISITID(void, copyConstructor, original);
 
        d_type = original.d_type;
    }
}
 
template <class t_HEAD, class... t_TAIL>
inline
Variant_Base<t_HEAD, t_TAIL...>::Variant_Base(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<Variant> original)
: AllocBase(allocator)
, d_type(bsl::variant_npos)
{
    Variant& lvalue = original;
    if (!lvalue.valueless_by_exception()) {
        BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(this);
        BSLSTL_VARIANT_VISITID(void, moveConstructor, lvalue);
 
        d_type = lvalue.d_type;
    }
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX>
inline
Variant_Base<t_HEAD, t_TAIL...>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism());
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX, class t_ARG_01>
inline
Variant_Base<t_HEAD, t_TAIL...>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01);
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
Variant_Base<t_HEAD, t_TAIL...>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
Variant_Base<t_HEAD, t_TAIL...>::Variant_Base(
                                      bsl::allocator_arg_t,
                                      allocator_type                 allocator,
                                      bsl::in_place_index_t<t_INDEX>,
                                      const t_ARG_01&                arg_01,
                                      const t_ARG_02&                arg_02,
                                      const t_ARG_03&                arg_03)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
Variant_Base<t_HEAD, t_TAIL...>::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
Variant_Base<t_HEAD, t_TAIL...>::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
Variant_Base<t_HEAD, t_TAIL...>::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
Variant_Base<t_HEAD, t_TAIL...>::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
Variant_Base<t_HEAD, t_TAIL...>::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
Variant_Base<t_HEAD, t_TAIL...>::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
Variant_Base<t_HEAD, t_TAIL...>::Variant_Base(bsl::allocator_arg_t,
                                              allocator_type allocator,
                                              bsl::in_place_index_t<t_INDEX>,
                                              const t_ARG_01& arg_01,
                                              const t_ARG_02& arg_02,
                                              const t_ARG_03& arg_03,
                                              const t_ARG_04& arg_04,
                                              const t_ARG_05& arg_05,
                                              const t_ARG_06& arg_06,
                                              const t_ARG_07& arg_07,
                                              const t_ARG_08& arg_08,
                                              const t_ARG_09& arg_09,
                                              const t_ARG_10& arg_10)
: AllocBase(allocator)
, d_type(t_INDEX)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *>(BSLS_UTIL_ADDRESSOF(d_union)),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
}
// }}} END GENERATED CODE
#endif
#endif  // BSL_VARIANT_FULL_IMPLEMENTATION
 
#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
// {{{ BEGIN GENERATED CODE
// Command line: sim_cpp11_features.pl bslstl_variant.h
#ifndef BSLSTL_VARIANT_VARIADIC_LIMIT
#define BSLSTL_VARIANT_VARIADIC_LIMIT 18
#endif
#ifndef BSLSTL_VARIANT_VARIADIC_LIMIT_M
#define BSLSTL_VARIANT_VARIADIC_LIMIT_M BSLSTL_VARIANT_VARIADIC_LIMIT
#endif
#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 0
template <class t_HEAD>
Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::~Variant_Base()
{
    reset();
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 1
template <class t_HEAD, class t_TAIL_01>
Variant_Base<t_HEAD, t_TAIL_01,
                     BSLS_COMPILERFEATURES_FILLT(17)>::~Variant_Base()
{
    reset();
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     BSLS_COMPILERFEATURES_FILLT(16)>::~Variant_Base()
{
    reset();
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     BSLS_COMPILERFEATURES_FILLT(15)>::~Variant_Base()
{
    reset();
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     BSLS_COMPILERFEATURES_FILLT(14)>::~Variant_Base()
{
    reset();
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     BSLS_COMPILERFEATURES_FILLT(13)>::~Variant_Base()
{
    reset();
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     BSLS_COMPILERFEATURES_FILLT(12)>::~Variant_Base()
{
    reset();
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     BSLS_COMPILERFEATURES_FILLT(11)>::~Variant_Base()
{
    reset();
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     BSLS_COMPILERFEATURES_FILLT(10)>::~Variant_Base()
{
    reset();
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     BSLS_COMPILERFEATURES_FILLT( 9)>::~Variant_Base()
{
    reset();
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     BSLS_COMPILERFEATURES_FILLT( 8)>::~Variant_Base()
{
    reset();
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     BSLS_COMPILERFEATURES_FILLT( 7)>::~Variant_Base()
{
    reset();
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     BSLS_COMPILERFEATURES_FILLT( 6)>::~Variant_Base()
{
    reset();
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     BSLS_COMPILERFEATURES_FILLT( 5)>::~Variant_Base()
{
    reset();
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     BSLS_COMPILERFEATURES_FILLT( 4)>::~Variant_Base()
{
    reset();
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     BSLS_COMPILERFEATURES_FILLT( 3)>::~Variant_Base()
{
    reset();
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     BSLS_COMPILERFEATURES_FILLT( 2)>::~Variant_Base()
{
    reset();
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     BSLS_COMPILERFEATURES_FILLT( 1)>::~Variant_Base()
{
    reset();
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     t_TAIL_18,
                     BSLS_COMPILERFEATURES_FILLT( 0)>::~Variant_Base()
{
    reset();
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 18
 
#else
// The generated code below is a workaround for the absence of perfect
// forwarding in some compilers.
template <class t_HEAD, class... t_TAIL>
Variant_Base<t_HEAD, t_TAIL...>::~Variant_Base()
{
    reset();
}
// }}} END GENERATED CODE
#endif
// MANIPULATORS
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX, class... t_ARGS>
void Variant_Base<t_HEAD, t_TAIL...>::baseEmplace(t_ARGS&&... args)
{
    reset();
 
    // We need to assemble the construction arguments for the underlying
    //'Variant_DataImp' object here.  They require that allocator pointer is
    // the leading argument after 'Variant_Union' strips the 't_INDEX'.  To be
    // able to get such argument set, we say that 'Variant_Union' is not
    // allocator aware.  If we were to have 'Variant_Union' be allocator aware
    // and use trailing allocator construction, we wouldn't be able to extract
    // the allocator to move it to the right position for the 'Variant_DataImp'
    // construct invocation.  If we were to have either 'Variant_Union' or
    // 'Variant_DataImp' use 'allocator_arg_t' semantics, it wouldn't work for
    // the non allocator aware variant where there is no allocator object.
    BloombergLP::bslma::ConstructionUtil::construct(
        BSLS_UTIL_ADDRESSOF(d_union),
        (void *)0,
        bsl::in_place_index_t<t_INDEX>{},
        AllocBase::mechanism(),
        std::forward<t_ARGS>(args)...);
    d_type = t_INDEX;
}
 
#else  // BSL_VARIANT_FULL_IMPLEMENTATION
#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
// {{{ BEGIN GENERATED CODE
// Command line: sim_cpp11_features.pl bslstl_variant.h
#ifndef BSLSTL_VARIANT_VARIADIC_LIMIT
#define BSLSTL_VARIANT_VARIADIC_LIMIT 18
#endif
#ifndef BSLSTL_VARIANT_VARIADIC_LIMIT_N
#define BSLSTL_VARIANT_VARIADIC_LIMIT_N BSLSTL_VARIANT_VARIADIC_LIMIT
#endif
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 0
template <class t_HEAD>
template <size_t t_INDEX>
void Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::baseEmplace()
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism());
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX>
void Variant_Base<t_HEAD, t_TAIL_01,
                          BSLS_COMPILERFEATURES_FILLT(17)>::baseEmplace()
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism());
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          BSLS_COMPILERFEATURES_FILLT(16)>::baseEmplace()
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism());
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          BSLS_COMPILERFEATURES_FILLT(15)>::baseEmplace()
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism());
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          BSLS_COMPILERFEATURES_FILLT(14)>::baseEmplace()
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism());
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          BSLS_COMPILERFEATURES_FILLT(13)>::baseEmplace()
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism());
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          BSLS_COMPILERFEATURES_FILLT(12)>::baseEmplace()
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism());
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          BSLS_COMPILERFEATURES_FILLT(11)>::baseEmplace()
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism());
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          BSLS_COMPILERFEATURES_FILLT(10)>::baseEmplace()
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism());
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          BSLS_COMPILERFEATURES_FILLT( 9)>::baseEmplace()
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism());
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          BSLS_COMPILERFEATURES_FILLT( 8)>::baseEmplace()
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism());
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          BSLS_COMPILERFEATURES_FILLT( 7)>::baseEmplace()
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism());
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          BSLS_COMPILERFEATURES_FILLT( 6)>::baseEmplace()
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism());
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          BSLS_COMPILERFEATURES_FILLT( 5)>::baseEmplace()
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism());
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          BSLS_COMPILERFEATURES_FILLT( 4)>::baseEmplace()
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism());
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          BSLS_COMPILERFEATURES_FILLT( 3)>::baseEmplace()
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism());
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          t_TAIL_16,
                          BSLS_COMPILERFEATURES_FILLT( 2)>::baseEmplace()
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism());
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          t_TAIL_16,
                          t_TAIL_17,
                          BSLS_COMPILERFEATURES_FILLT( 1)>::baseEmplace()
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism());
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          t_TAIL_16,
                          t_TAIL_17,
                          t_TAIL_18,
                          BSLS_COMPILERFEATURES_FILLT( 0)>::baseEmplace()
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism());
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 0
template <class t_HEAD>
template <size_t t_INDEX, class t_ARG_01>
void Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                          >::baseEmplace(const t_ARG_01& arg_01)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX, class t_ARG_01>
void Variant_Base<t_HEAD, t_TAIL_01,
                          BSLS_COMPILERFEATURES_FILLT(17)
                          >::baseEmplace(const t_ARG_01& arg_01)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX, class t_ARG_01>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          BSLS_COMPILERFEATURES_FILLT(16)
                          >::baseEmplace(const t_ARG_01& arg_01)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX, class t_ARG_01>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          BSLS_COMPILERFEATURES_FILLT(15)
                          >::baseEmplace(const t_ARG_01& arg_01)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX, class t_ARG_01>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          BSLS_COMPILERFEATURES_FILLT(14)
                          >::baseEmplace(const t_ARG_01& arg_01)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX, class t_ARG_01>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          BSLS_COMPILERFEATURES_FILLT(13)
                          >::baseEmplace(const t_ARG_01& arg_01)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX, class t_ARG_01>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          BSLS_COMPILERFEATURES_FILLT(12)
                          >::baseEmplace(const t_ARG_01& arg_01)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX, class t_ARG_01>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          BSLS_COMPILERFEATURES_FILLT(11)
                          >::baseEmplace(const t_ARG_01& arg_01)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX, class t_ARG_01>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          BSLS_COMPILERFEATURES_FILLT(10)
                          >::baseEmplace(const t_ARG_01& arg_01)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX, class t_ARG_01>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          BSLS_COMPILERFEATURES_FILLT( 9)
                          >::baseEmplace(const t_ARG_01& arg_01)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX, class t_ARG_01>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          BSLS_COMPILERFEATURES_FILLT( 8)
                          >::baseEmplace(const t_ARG_01& arg_01)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX, class t_ARG_01>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          BSLS_COMPILERFEATURES_FILLT( 7)
                          >::baseEmplace(const t_ARG_01& arg_01)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX, class t_ARG_01>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          BSLS_COMPILERFEATURES_FILLT( 6)
                          >::baseEmplace(const t_ARG_01& arg_01)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX, class t_ARG_01>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          BSLS_COMPILERFEATURES_FILLT( 5)
                          >::baseEmplace(const t_ARG_01& arg_01)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX, class t_ARG_01>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          BSLS_COMPILERFEATURES_FILLT( 4)
                          >::baseEmplace(const t_ARG_01& arg_01)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX, class t_ARG_01>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          BSLS_COMPILERFEATURES_FILLT( 3)
                          >::baseEmplace(const t_ARG_01& arg_01)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX, class t_ARG_01>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          t_TAIL_16,
                          BSLS_COMPILERFEATURES_FILLT( 2)
                          >::baseEmplace(const t_ARG_01& arg_01)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX, class t_ARG_01>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          t_TAIL_16,
                          t_TAIL_17,
                          BSLS_COMPILERFEATURES_FILLT( 1)
                          >::baseEmplace(const t_ARG_01& arg_01)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX, class t_ARG_01>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          t_TAIL_16,
                          t_TAIL_17,
                          t_TAIL_18,
                          BSLS_COMPILERFEATURES_FILLT( 0)
                          >::baseEmplace(const t_ARG_01& arg_01)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 0
template <class t_HEAD>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
void Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
void Variant_Base<t_HEAD, t_TAIL_01,
                          BSLS_COMPILERFEATURES_FILLT(17)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          BSLS_COMPILERFEATURES_FILLT(16)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          BSLS_COMPILERFEATURES_FILLT(15)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          BSLS_COMPILERFEATURES_FILLT(14)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          BSLS_COMPILERFEATURES_FILLT(13)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          BSLS_COMPILERFEATURES_FILLT(12)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          BSLS_COMPILERFEATURES_FILLT(11)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          BSLS_COMPILERFEATURES_FILLT(10)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          BSLS_COMPILERFEATURES_FILLT( 9)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          BSLS_COMPILERFEATURES_FILLT( 8)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          BSLS_COMPILERFEATURES_FILLT( 7)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          BSLS_COMPILERFEATURES_FILLT( 6)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          BSLS_COMPILERFEATURES_FILLT( 5)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          BSLS_COMPILERFEATURES_FILLT( 4)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          BSLS_COMPILERFEATURES_FILLT( 3)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          t_TAIL_16,
                          BSLS_COMPILERFEATURES_FILLT( 2)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          t_TAIL_16,
                          t_TAIL_17,
                          BSLS_COMPILERFEATURES_FILLT( 1)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          t_TAIL_16,
                          t_TAIL_17,
                          t_TAIL_18,
                          BSLS_COMPILERFEATURES_FILLT( 0)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 0
template <class t_HEAD>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
void Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
void Variant_Base<t_HEAD, t_TAIL_01,
                          BSLS_COMPILERFEATURES_FILLT(17)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          BSLS_COMPILERFEATURES_FILLT(16)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          BSLS_COMPILERFEATURES_FILLT(15)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          BSLS_COMPILERFEATURES_FILLT(14)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          BSLS_COMPILERFEATURES_FILLT(13)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          BSLS_COMPILERFEATURES_FILLT(12)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          BSLS_COMPILERFEATURES_FILLT(11)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          BSLS_COMPILERFEATURES_FILLT(10)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          BSLS_COMPILERFEATURES_FILLT( 9)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          BSLS_COMPILERFEATURES_FILLT( 8)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          BSLS_COMPILERFEATURES_FILLT( 7)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          BSLS_COMPILERFEATURES_FILLT( 6)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          BSLS_COMPILERFEATURES_FILLT( 5)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          BSLS_COMPILERFEATURES_FILLT( 4)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          BSLS_COMPILERFEATURES_FILLT( 3)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          t_TAIL_16,
                          BSLS_COMPILERFEATURES_FILLT( 2)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          t_TAIL_16,
                          t_TAIL_17,
                          BSLS_COMPILERFEATURES_FILLT( 1)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          t_TAIL_16,
                          t_TAIL_17,
                          t_TAIL_18,
                          BSLS_COMPILERFEATURES_FILLT( 0)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
void Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
void Variant_Base<t_HEAD, t_TAIL_01,
                          BSLS_COMPILERFEATURES_FILLT(17)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          BSLS_COMPILERFEATURES_FILLT(16)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          BSLS_COMPILERFEATURES_FILLT(15)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          BSLS_COMPILERFEATURES_FILLT(14)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          BSLS_COMPILERFEATURES_FILLT(13)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          BSLS_COMPILERFEATURES_FILLT(12)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          BSLS_COMPILERFEATURES_FILLT(11)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          BSLS_COMPILERFEATURES_FILLT(10)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          BSLS_COMPILERFEATURES_FILLT( 9)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          BSLS_COMPILERFEATURES_FILLT( 8)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          BSLS_COMPILERFEATURES_FILLT( 7)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          BSLS_COMPILERFEATURES_FILLT( 6)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          BSLS_COMPILERFEATURES_FILLT( 5)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          BSLS_COMPILERFEATURES_FILLT( 4)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          BSLS_COMPILERFEATURES_FILLT( 3)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          t_TAIL_16,
                          BSLS_COMPILERFEATURES_FILLT( 2)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          t_TAIL_16,
                          t_TAIL_17,
                          BSLS_COMPILERFEATURES_FILLT( 1)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          t_TAIL_16,
                          t_TAIL_17,
                          t_TAIL_18,
                          BSLS_COMPILERFEATURES_FILLT( 0)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
void Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
void Variant_Base<t_HEAD, t_TAIL_01,
                          BSLS_COMPILERFEATURES_FILLT(17)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          BSLS_COMPILERFEATURES_FILLT(16)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          BSLS_COMPILERFEATURES_FILLT(15)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          BSLS_COMPILERFEATURES_FILLT(14)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          BSLS_COMPILERFEATURES_FILLT(13)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          BSLS_COMPILERFEATURES_FILLT(12)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          BSLS_COMPILERFEATURES_FILLT(11)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          BSLS_COMPILERFEATURES_FILLT(10)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          BSLS_COMPILERFEATURES_FILLT( 9)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          BSLS_COMPILERFEATURES_FILLT( 8)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          BSLS_COMPILERFEATURES_FILLT( 7)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          BSLS_COMPILERFEATURES_FILLT( 6)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          BSLS_COMPILERFEATURES_FILLT( 5)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          BSLS_COMPILERFEATURES_FILLT( 4)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          BSLS_COMPILERFEATURES_FILLT( 3)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          t_TAIL_16,
                          BSLS_COMPILERFEATURES_FILLT( 2)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          t_TAIL_16,
                          t_TAIL_17,
                          BSLS_COMPILERFEATURES_FILLT( 1)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          t_TAIL_16,
                          t_TAIL_17,
                          t_TAIL_18,
                          BSLS_COMPILERFEATURES_FILLT( 0)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
void Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
void Variant_Base<t_HEAD, t_TAIL_01,
                          BSLS_COMPILERFEATURES_FILLT(17)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          BSLS_COMPILERFEATURES_FILLT(16)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          BSLS_COMPILERFEATURES_FILLT(15)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          BSLS_COMPILERFEATURES_FILLT(14)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          BSLS_COMPILERFEATURES_FILLT(13)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          BSLS_COMPILERFEATURES_FILLT(12)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          BSLS_COMPILERFEATURES_FILLT(11)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          BSLS_COMPILERFEATURES_FILLT(10)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          BSLS_COMPILERFEATURES_FILLT( 9)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          BSLS_COMPILERFEATURES_FILLT( 8)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          BSLS_COMPILERFEATURES_FILLT( 7)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          BSLS_COMPILERFEATURES_FILLT( 6)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          BSLS_COMPILERFEATURES_FILLT( 5)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          BSLS_COMPILERFEATURES_FILLT( 4)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          BSLS_COMPILERFEATURES_FILLT( 3)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          t_TAIL_16,
                          BSLS_COMPILERFEATURES_FILLT( 2)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          t_TAIL_16,
                          t_TAIL_17,
                          BSLS_COMPILERFEATURES_FILLT( 1)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          t_TAIL_16,
                          t_TAIL_17,
                          t_TAIL_18,
                          BSLS_COMPILERFEATURES_FILLT( 0)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
void Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
void Variant_Base<t_HEAD, t_TAIL_01,
                          BSLS_COMPILERFEATURES_FILLT(17)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          BSLS_COMPILERFEATURES_FILLT(16)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          BSLS_COMPILERFEATURES_FILLT(15)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          BSLS_COMPILERFEATURES_FILLT(14)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          BSLS_COMPILERFEATURES_FILLT(13)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          BSLS_COMPILERFEATURES_FILLT(12)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          BSLS_COMPILERFEATURES_FILLT(11)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          BSLS_COMPILERFEATURES_FILLT(10)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          BSLS_COMPILERFEATURES_FILLT( 9)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          BSLS_COMPILERFEATURES_FILLT( 8)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          BSLS_COMPILERFEATURES_FILLT( 7)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          BSLS_COMPILERFEATURES_FILLT( 6)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          BSLS_COMPILERFEATURES_FILLT( 5)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          BSLS_COMPILERFEATURES_FILLT( 4)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          BSLS_COMPILERFEATURES_FILLT( 3)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          t_TAIL_16,
                          BSLS_COMPILERFEATURES_FILLT( 2)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          t_TAIL_16,
                          t_TAIL_17,
                          BSLS_COMPILERFEATURES_FILLT( 1)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          t_TAIL_16,
                          t_TAIL_17,
                          t_TAIL_18,
                          BSLS_COMPILERFEATURES_FILLT( 0)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
void Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
void Variant_Base<t_HEAD, t_TAIL_01,
                          BSLS_COMPILERFEATURES_FILLT(17)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          BSLS_COMPILERFEATURES_FILLT(16)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          BSLS_COMPILERFEATURES_FILLT(15)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          BSLS_COMPILERFEATURES_FILLT(14)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          BSLS_COMPILERFEATURES_FILLT(13)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          BSLS_COMPILERFEATURES_FILLT(12)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          BSLS_COMPILERFEATURES_FILLT(11)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          BSLS_COMPILERFEATURES_FILLT(10)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          BSLS_COMPILERFEATURES_FILLT( 9)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          BSLS_COMPILERFEATURES_FILLT( 8)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          BSLS_COMPILERFEATURES_FILLT( 7)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          BSLS_COMPILERFEATURES_FILLT( 6)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          BSLS_COMPILERFEATURES_FILLT( 5)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          BSLS_COMPILERFEATURES_FILLT( 4)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          BSLS_COMPILERFEATURES_FILLT( 3)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          t_TAIL_16,
                          BSLS_COMPILERFEATURES_FILLT( 2)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          t_TAIL_16,
                          t_TAIL_17,
                          BSLS_COMPILERFEATURES_FILLT( 1)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          t_TAIL_16,
                          t_TAIL_17,
                          t_TAIL_18,
                          BSLS_COMPILERFEATURES_FILLT( 0)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
void Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
void Variant_Base<t_HEAD, t_TAIL_01,
                          BSLS_COMPILERFEATURES_FILLT(17)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          BSLS_COMPILERFEATURES_FILLT(16)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          BSLS_COMPILERFEATURES_FILLT(15)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          BSLS_COMPILERFEATURES_FILLT(14)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          BSLS_COMPILERFEATURES_FILLT(13)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          BSLS_COMPILERFEATURES_FILLT(12)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          BSLS_COMPILERFEATURES_FILLT(11)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          BSLS_COMPILERFEATURES_FILLT(10)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          BSLS_COMPILERFEATURES_FILLT( 9)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          BSLS_COMPILERFEATURES_FILLT( 8)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          BSLS_COMPILERFEATURES_FILLT( 7)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          BSLS_COMPILERFEATURES_FILLT( 6)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          BSLS_COMPILERFEATURES_FILLT( 5)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          BSLS_COMPILERFEATURES_FILLT( 4)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          BSLS_COMPILERFEATURES_FILLT( 3)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          t_TAIL_16,
                          BSLS_COMPILERFEATURES_FILLT( 2)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          t_TAIL_16,
                          t_TAIL_17,
                          BSLS_COMPILERFEATURES_FILLT( 1)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          t_TAIL_16,
                          t_TAIL_17,
                          t_TAIL_18,
                          BSLS_COMPILERFEATURES_FILLT( 0)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
void Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09,
                                                  const t_ARG_10& arg_10)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
void Variant_Base<t_HEAD, t_TAIL_01,
                          BSLS_COMPILERFEATURES_FILLT(17)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09,
                                                  const t_ARG_10& arg_10)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          BSLS_COMPILERFEATURES_FILLT(16)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09,
                                                  const t_ARG_10& arg_10)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          BSLS_COMPILERFEATURES_FILLT(15)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09,
                                                  const t_ARG_10& arg_10)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          BSLS_COMPILERFEATURES_FILLT(14)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09,
                                                  const t_ARG_10& arg_10)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          BSLS_COMPILERFEATURES_FILLT(13)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09,
                                                  const t_ARG_10& arg_10)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          BSLS_COMPILERFEATURES_FILLT(12)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09,
                                                  const t_ARG_10& arg_10)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          BSLS_COMPILERFEATURES_FILLT(11)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09,
                                                  const t_ARG_10& arg_10)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          BSLS_COMPILERFEATURES_FILLT(10)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09,
                                                  const t_ARG_10& arg_10)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          BSLS_COMPILERFEATURES_FILLT( 9)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09,
                                                  const t_ARG_10& arg_10)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          BSLS_COMPILERFEATURES_FILLT( 8)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09,
                                                  const t_ARG_10& arg_10)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          BSLS_COMPILERFEATURES_FILLT( 7)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09,
                                                  const t_ARG_10& arg_10)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          BSLS_COMPILERFEATURES_FILLT( 6)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09,
                                                  const t_ARG_10& arg_10)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          BSLS_COMPILERFEATURES_FILLT( 5)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09,
                                                  const t_ARG_10& arg_10)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          BSLS_COMPILERFEATURES_FILLT( 4)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09,
                                                  const t_ARG_10& arg_10)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          BSLS_COMPILERFEATURES_FILLT( 3)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09,
                                                  const t_ARG_10& arg_10)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          t_TAIL_16,
                          BSLS_COMPILERFEATURES_FILLT( 2)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09,
                                                  const t_ARG_10& arg_10)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          t_TAIL_16,
                          t_TAIL_17,
                          BSLS_COMPILERFEATURES_FILLT( 1)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09,
                                                  const t_ARG_10& arg_10)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          t_TAIL_16,
                          t_TAIL_17,
                          t_TAIL_18,
                          BSLS_COMPILERFEATURES_FILLT( 0)
                          >::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09,
                                                  const t_ARG_10& arg_10)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
    d_type = t_INDEX;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 18
 
#else
// The generated code below is a workaround for the absence of perfect
// forwarding in some compilers.
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX>
void Variant_Base<t_HEAD, t_TAIL...>::baseEmplace()
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism());
    d_type = t_INDEX;
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX, class t_ARG_01>
void Variant_Base<t_HEAD, t_TAIL...>::baseEmplace(const t_ARG_01& arg_01)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01);
    d_type = t_INDEX;
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
void Variant_Base<t_HEAD, t_TAIL...>::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02);
    d_type = t_INDEX;
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
void Variant_Base<t_HEAD, t_TAIL...>::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03);
    d_type = t_INDEX;
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
void Variant_Base<t_HEAD, t_TAIL...>::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04);
    d_type = t_INDEX;
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
void Variant_Base<t_HEAD, t_TAIL...>::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05);
    d_type = t_INDEX;
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
void Variant_Base<t_HEAD, t_TAIL...>::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06);
    d_type = t_INDEX;
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
void Variant_Base<t_HEAD, t_TAIL...>::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07);
    d_type = t_INDEX;
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
void Variant_Base<t_HEAD, t_TAIL...>::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08);
    d_type = t_INDEX;
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
void Variant_Base<t_HEAD, t_TAIL...>::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09);
    d_type = t_INDEX;
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
void Variant_Base<t_HEAD, t_TAIL...>::baseEmplace(const t_ARG_01& arg_01,
                                                  const t_ARG_02& arg_02,
                                                  const t_ARG_03& arg_03,
                                                  const t_ARG_04& arg_04,
                                                  const t_ARG_05& arg_05,
                                                  const t_ARG_06& arg_06,
                                                  const t_ARG_07& arg_07,
                                                  const t_ARG_08& arg_08,
                                                  const t_ARG_09& arg_09,
                                                  const t_ARG_10& arg_10)
{
    typedef typename bsl::remove_cv<
        typename bsl::variant_alternative<t_INDEX, Variant>::type>::type
        Alt_Type;
 
    reset();
 
    BloombergLP::bslma::ConstructionUtil::construct(
        reinterpret_cast<Alt_Type *> BSLS_UTIL_ADDRESSOF(d_union),
        AllocBase::mechanism(),
        arg_01,
        arg_02,
        arg_03,
        arg_04,
        arg_05,
        arg_06,
        arg_07,
        arg_08,
        arg_09,
        arg_10);
    d_type = t_INDEX;
}
// }}} END GENERATED CODE
#endif
#endif  // BSL_VARIANT_FULL_IMPLEMENTATION
 
#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
// {{{ BEGIN GENERATED CODE
// Command line: sim_cpp11_features.pl bslstl_variant.h
#ifndef BSLSTL_VARIANT_VARIADIC_LIMIT
#define BSLSTL_VARIANT_VARIADIC_LIMIT 18
#endif
#ifndef BSLSTL_VARIANT_VARIADIC_LIMIT_O
#define BSLSTL_VARIANT_VARIADIC_LIMIT_O BSLSTL_VARIANT_VARIADIC_LIMIT
#endif
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 0
template <class t_HEAD>
inline
Variant_Base<t_HEAD>& Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                                           >::operator=(
                                                       const Variant_Base& rhs)
{
    if (&rhs != this) {
        if (this->d_type == rhs.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_CopyAssignVisitor<Variant>
                copyAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, copyAssign, static_cast<const Variant&>(rhs));
            }
        }
        else {
            reset();
            if (rhs.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
                    copyConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, copyConstructor, static_cast<const Variant&>(rhs));
            }
            d_type = rhs.d_type;
        }
    }
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 1
template <class t_HEAD, class t_TAIL_01>
inline
Variant_Base<t_HEAD, t_TAIL_01>& Variant_Base<t_HEAD,
                                                t_TAIL_01,
                                                BSLS_COMPILERFEATURES_FILLT(17)
                                                >::operator=(
                                                       const Variant_Base& rhs)
{
    if (&rhs != this) {
        if (this->d_type == rhs.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_CopyAssignVisitor<Variant>
                copyAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, copyAssign, static_cast<const Variant&>(rhs));
            }
        }
        else {
            reset();
            if (rhs.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
                    copyConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, copyConstructor, static_cast<const Variant&>(rhs));
            }
            d_type = rhs.d_type;
        }
    }
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02>& Variant_Base<t_HEAD,
                                                t_TAIL_01,
                                                t_TAIL_02,
                                                BSLS_COMPILERFEATURES_FILLT(16)
                                                >::operator=(
                                                       const Variant_Base& rhs)
{
    if (&rhs != this) {
        if (this->d_type == rhs.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_CopyAssignVisitor<Variant>
                copyAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, copyAssign, static_cast<const Variant&>(rhs));
            }
        }
        else {
            reset();
            if (rhs.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
                    copyConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, copyConstructor, static_cast<const Variant&>(rhs));
            }
            d_type = rhs.d_type;
        }
    }
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03>& Variant_Base<t_HEAD,
                                                t_TAIL_01,
                                                t_TAIL_02,
                                                t_TAIL_03,
                                                BSLS_COMPILERFEATURES_FILLT(15)
                                                >::operator=(
                                                       const Variant_Base& rhs)
{
    if (&rhs != this) {
        if (this->d_type == rhs.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_CopyAssignVisitor<Variant>
                copyAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, copyAssign, static_cast<const Variant&>(rhs));
            }
        }
        else {
            reset();
            if (rhs.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
                    copyConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, copyConstructor, static_cast<const Variant&>(rhs));
            }
            d_type = rhs.d_type;
        }
    }
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04>& Variant_Base<t_HEAD,
                                                t_TAIL_01,
                                                t_TAIL_02,
                                                t_TAIL_03,
                                                t_TAIL_04,
                                                BSLS_COMPILERFEATURES_FILLT(14)
                                                >::operator=(
                                                       const Variant_Base& rhs)
{
    if (&rhs != this) {
        if (this->d_type == rhs.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_CopyAssignVisitor<Variant>
                copyAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, copyAssign, static_cast<const Variant&>(rhs));
            }
        }
        else {
            reset();
            if (rhs.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
                    copyConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, copyConstructor, static_cast<const Variant&>(rhs));
            }
            d_type = rhs.d_type;
        }
    }
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05>& Variant_Base<t_HEAD,
                                                t_TAIL_01,
                                                t_TAIL_02,
                                                t_TAIL_03,
                                                t_TAIL_04,
                                                t_TAIL_05,
                                                BSLS_COMPILERFEATURES_FILLT(13)
                                                >::operator=(
                                                       const Variant_Base& rhs)
{
    if (&rhs != this) {
        if (this->d_type == rhs.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_CopyAssignVisitor<Variant>
                copyAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, copyAssign, static_cast<const Variant&>(rhs));
            }
        }
        else {
            reset();
            if (rhs.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
                    copyConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, copyConstructor, static_cast<const Variant&>(rhs));
            }
            d_type = rhs.d_type;
        }
    }
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06>& Variant_Base<t_HEAD,
                                                t_TAIL_01,
                                                t_TAIL_02,
                                                t_TAIL_03,
                                                t_TAIL_04,
                                                t_TAIL_05,
                                                t_TAIL_06,
                                                BSLS_COMPILERFEATURES_FILLT(12)
                                                >::operator=(
                                                       const Variant_Base& rhs)
{
    if (&rhs != this) {
        if (this->d_type == rhs.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_CopyAssignVisitor<Variant>
                copyAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, copyAssign, static_cast<const Variant&>(rhs));
            }
        }
        else {
            reset();
            if (rhs.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
                    copyConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, copyConstructor, static_cast<const Variant&>(rhs));
            }
            d_type = rhs.d_type;
        }
    }
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07>& Variant_Base<t_HEAD,
                                                t_TAIL_01,
                                                t_TAIL_02,
                                                t_TAIL_03,
                                                t_TAIL_04,
                                                t_TAIL_05,
                                                t_TAIL_06,
                                                t_TAIL_07,
                                                BSLS_COMPILERFEATURES_FILLT(11)
                                                >::operator=(
                                                       const Variant_Base& rhs)
{
    if (&rhs != this) {
        if (this->d_type == rhs.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_CopyAssignVisitor<Variant>
                copyAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, copyAssign, static_cast<const Variant&>(rhs));
            }
        }
        else {
            reset();
            if (rhs.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
                    copyConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, copyConstructor, static_cast<const Variant&>(rhs));
            }
            d_type = rhs.d_type;
        }
    }
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08>& Variant_Base<t_HEAD,
                                                t_TAIL_01,
                                                t_TAIL_02,
                                                t_TAIL_03,
                                                t_TAIL_04,
                                                t_TAIL_05,
                                                t_TAIL_06,
                                                t_TAIL_07,
                                                t_TAIL_08,
                                                BSLS_COMPILERFEATURES_FILLT(10)
                                                >::operator=(
                                                       const Variant_Base& rhs)
{
    if (&rhs != this) {
        if (this->d_type == rhs.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_CopyAssignVisitor<Variant>
                copyAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, copyAssign, static_cast<const Variant&>(rhs));
            }
        }
        else {
            reset();
            if (rhs.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
                    copyConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, copyConstructor, static_cast<const Variant&>(rhs));
            }
            d_type = rhs.d_type;
        }
    }
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09>& Variant_Base<t_HEAD,
                                                t_TAIL_01,
                                                t_TAIL_02,
                                                t_TAIL_03,
                                                t_TAIL_04,
                                                t_TAIL_05,
                                                t_TAIL_06,
                                                t_TAIL_07,
                                                t_TAIL_08,
                                                t_TAIL_09,
                                                BSLS_COMPILERFEATURES_FILLT( 9)
                                                >::operator=(
                                                       const Variant_Base& rhs)
{
    if (&rhs != this) {
        if (this->d_type == rhs.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_CopyAssignVisitor<Variant>
                copyAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, copyAssign, static_cast<const Variant&>(rhs));
            }
        }
        else {
            reset();
            if (rhs.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
                    copyConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, copyConstructor, static_cast<const Variant&>(rhs));
            }
            d_type = rhs.d_type;
        }
    }
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10>& Variant_Base<t_HEAD,
                                                t_TAIL_01,
                                                t_TAIL_02,
                                                t_TAIL_03,
                                                t_TAIL_04,
                                                t_TAIL_05,
                                                t_TAIL_06,
                                                t_TAIL_07,
                                                t_TAIL_08,
                                                t_TAIL_09,
                                                t_TAIL_10,
                                                BSLS_COMPILERFEATURES_FILLT( 8)
                                                >::operator=(
                                                       const Variant_Base& rhs)
{
    if (&rhs != this) {
        if (this->d_type == rhs.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_CopyAssignVisitor<Variant>
                copyAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, copyAssign, static_cast<const Variant&>(rhs));
            }
        }
        else {
            reset();
            if (rhs.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
                    copyConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, copyConstructor, static_cast<const Variant&>(rhs));
            }
            d_type = rhs.d_type;
        }
    }
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11>& Variant_Base<t_HEAD,
                                                t_TAIL_01,
                                                t_TAIL_02,
                                                t_TAIL_03,
                                                t_TAIL_04,
                                                t_TAIL_05,
                                                t_TAIL_06,
                                                t_TAIL_07,
                                                t_TAIL_08,
                                                t_TAIL_09,
                                                t_TAIL_10,
                                                t_TAIL_11,
                                                BSLS_COMPILERFEATURES_FILLT( 7)
                                                >::operator=(
                                                       const Variant_Base& rhs)
{
    if (&rhs != this) {
        if (this->d_type == rhs.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_CopyAssignVisitor<Variant>
                copyAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, copyAssign, static_cast<const Variant&>(rhs));
            }
        }
        else {
            reset();
            if (rhs.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
                    copyConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, copyConstructor, static_cast<const Variant&>(rhs));
            }
            d_type = rhs.d_type;
        }
    }
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12>& Variant_Base<t_HEAD,
                                                t_TAIL_01,
                                                t_TAIL_02,
                                                t_TAIL_03,
                                                t_TAIL_04,
                                                t_TAIL_05,
                                                t_TAIL_06,
                                                t_TAIL_07,
                                                t_TAIL_08,
                                                t_TAIL_09,
                                                t_TAIL_10,
                                                t_TAIL_11,
                                                t_TAIL_12,
                                                BSLS_COMPILERFEATURES_FILLT( 6)
                                                >::operator=(
                                                       const Variant_Base& rhs)
{
    if (&rhs != this) {
        if (this->d_type == rhs.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_CopyAssignVisitor<Variant>
                copyAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, copyAssign, static_cast<const Variant&>(rhs));
            }
        }
        else {
            reset();
            if (rhs.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
                    copyConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, copyConstructor, static_cast<const Variant&>(rhs));
            }
            d_type = rhs.d_type;
        }
    }
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13>& Variant_Base<t_HEAD,
                                                t_TAIL_01,
                                                t_TAIL_02,
                                                t_TAIL_03,
                                                t_TAIL_04,
                                                t_TAIL_05,
                                                t_TAIL_06,
                                                t_TAIL_07,
                                                t_TAIL_08,
                                                t_TAIL_09,
                                                t_TAIL_10,
                                                t_TAIL_11,
                                                t_TAIL_12,
                                                t_TAIL_13,
                                                BSLS_COMPILERFEATURES_FILLT( 5)
                                                >::operator=(
                                                       const Variant_Base& rhs)
{
    if (&rhs != this) {
        if (this->d_type == rhs.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_CopyAssignVisitor<Variant>
                copyAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, copyAssign, static_cast<const Variant&>(rhs));
            }
        }
        else {
            reset();
            if (rhs.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
                    copyConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, copyConstructor, static_cast<const Variant&>(rhs));
            }
            d_type = rhs.d_type;
        }
    }
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14>& Variant_Base<t_HEAD,
                                                t_TAIL_01,
                                                t_TAIL_02,
                                                t_TAIL_03,
                                                t_TAIL_04,
                                                t_TAIL_05,
                                                t_TAIL_06,
                                                t_TAIL_07,
                                                t_TAIL_08,
                                                t_TAIL_09,
                                                t_TAIL_10,
                                                t_TAIL_11,
                                                t_TAIL_12,
                                                t_TAIL_13,
                                                t_TAIL_14,
                                                BSLS_COMPILERFEATURES_FILLT( 4)
                                                >::operator=(
                                                       const Variant_Base& rhs)
{
    if (&rhs != this) {
        if (this->d_type == rhs.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_CopyAssignVisitor<Variant>
                copyAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, copyAssign, static_cast<const Variant&>(rhs));
            }
        }
        else {
            reset();
            if (rhs.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
                    copyConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, copyConstructor, static_cast<const Variant&>(rhs));
            }
            d_type = rhs.d_type;
        }
    }
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15>& Variant_Base<t_HEAD,
                                                t_TAIL_01,
                                                t_TAIL_02,
                                                t_TAIL_03,
                                                t_TAIL_04,
                                                t_TAIL_05,
                                                t_TAIL_06,
                                                t_TAIL_07,
                                                t_TAIL_08,
                                                t_TAIL_09,
                                                t_TAIL_10,
                                                t_TAIL_11,
                                                t_TAIL_12,
                                                t_TAIL_13,
                                                t_TAIL_14,
                                                t_TAIL_15,
                                                BSLS_COMPILERFEATURES_FILLT( 3)
                                                >::operator=(
                                                       const Variant_Base& rhs)
{
    if (&rhs != this) {
        if (this->d_type == rhs.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_CopyAssignVisitor<Variant>
                copyAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, copyAssign, static_cast<const Variant&>(rhs));
            }
        }
        else {
            reset();
            if (rhs.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
                    copyConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, copyConstructor, static_cast<const Variant&>(rhs));
            }
            d_type = rhs.d_type;
        }
    }
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16>& Variant_Base<t_HEAD,
                                                t_TAIL_01,
                                                t_TAIL_02,
                                                t_TAIL_03,
                                                t_TAIL_04,
                                                t_TAIL_05,
                                                t_TAIL_06,
                                                t_TAIL_07,
                                                t_TAIL_08,
                                                t_TAIL_09,
                                                t_TAIL_10,
                                                t_TAIL_11,
                                                t_TAIL_12,
                                                t_TAIL_13,
                                                t_TAIL_14,
                                                t_TAIL_15,
                                                t_TAIL_16,
                                                BSLS_COMPILERFEATURES_FILLT( 2)
                                                >::operator=(
                                                       const Variant_Base& rhs)
{
    if (&rhs != this) {
        if (this->d_type == rhs.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_CopyAssignVisitor<Variant>
                copyAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, copyAssign, static_cast<const Variant&>(rhs));
            }
        }
        else {
            reset();
            if (rhs.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
                    copyConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, copyConstructor, static_cast<const Variant&>(rhs));
            }
            d_type = rhs.d_type;
        }
    }
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17>& Variant_Base<t_HEAD,
                                                t_TAIL_01,
                                                t_TAIL_02,
                                                t_TAIL_03,
                                                t_TAIL_04,
                                                t_TAIL_05,
                                                t_TAIL_06,
                                                t_TAIL_07,
                                                t_TAIL_08,
                                                t_TAIL_09,
                                                t_TAIL_10,
                                                t_TAIL_11,
                                                t_TAIL_12,
                                                t_TAIL_13,
                                                t_TAIL_14,
                                                t_TAIL_15,
                                                t_TAIL_16,
                                                t_TAIL_17,
                                                BSLS_COMPILERFEATURES_FILLT( 1)
                                                >::operator=(
                                                       const Variant_Base& rhs)
{
    if (&rhs != this) {
        if (this->d_type == rhs.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_CopyAssignVisitor<Variant>
                copyAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, copyAssign, static_cast<const Variant&>(rhs));
            }
        }
        else {
            reset();
            if (rhs.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
                    copyConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, copyConstructor, static_cast<const Variant&>(rhs));
            }
            d_type = rhs.d_type;
        }
    }
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     t_TAIL_18>& Variant_Base<t_HEAD,
                                                t_TAIL_01,
                                                t_TAIL_02,
                                                t_TAIL_03,
                                                t_TAIL_04,
                                                t_TAIL_05,
                                                t_TAIL_06,
                                                t_TAIL_07,
                                                t_TAIL_08,
                                                t_TAIL_09,
                                                t_TAIL_10,
                                                t_TAIL_11,
                                                t_TAIL_12,
                                                t_TAIL_13,
                                                t_TAIL_14,
                                                t_TAIL_15,
                                                t_TAIL_16,
                                                t_TAIL_17,
                                                t_TAIL_18,
                                                BSLS_COMPILERFEATURES_FILLT( 0)
                                                >::operator=(
                                                       const Variant_Base& rhs)
{
    if (&rhs != this) {
        if (this->d_type == rhs.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_CopyAssignVisitor<Variant>
                copyAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, copyAssign, static_cast<const Variant&>(rhs));
            }
        }
        else {
            reset();
            if (rhs.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
                    copyConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, copyConstructor, static_cast<const Variant&>(rhs));
            }
            d_type = rhs.d_type;
        }
    }
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 0
template <class t_HEAD>
inline
Variant_Base<t_HEAD>& Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                                           >::operator=(
                              BloombergLP::bslmf::MovableRef<Variant_Base> rhs)
{
    Variant_Base& lvalue = rhs;
    if (&lvalue != this) {
        if (this->d_type == lvalue.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_MoveAssignVisitor<Variant>
                moveAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, moveAssign, static_cast<Variant&>(lvalue));
            }
        }
        else {
            reset();
            if (lvalue.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, moveConstructor, static_cast<Variant&>(lvalue));
            }
            d_type = lvalue.d_type;
        }
    }
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 1
template <class t_HEAD, class t_TAIL_01>
inline
Variant_Base<t_HEAD, t_TAIL_01>& Variant_Base<t_HEAD,
                                                t_TAIL_01,
                                                BSLS_COMPILERFEATURES_FILLT(17)
                                                >::operator=(
                              BloombergLP::bslmf::MovableRef<Variant_Base> rhs)
{
    Variant_Base& lvalue = rhs;
    if (&lvalue != this) {
        if (this->d_type == lvalue.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_MoveAssignVisitor<Variant>
                moveAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, moveAssign, static_cast<Variant&>(lvalue));
            }
        }
        else {
            reset();
            if (lvalue.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, moveConstructor, static_cast<Variant&>(lvalue));
            }
            d_type = lvalue.d_type;
        }
    }
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02>& Variant_Base<t_HEAD,
                                                t_TAIL_01,
                                                t_TAIL_02,
                                                BSLS_COMPILERFEATURES_FILLT(16)
                                                >::operator=(
                              BloombergLP::bslmf::MovableRef<Variant_Base> rhs)
{
    Variant_Base& lvalue = rhs;
    if (&lvalue != this) {
        if (this->d_type == lvalue.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_MoveAssignVisitor<Variant>
                moveAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, moveAssign, static_cast<Variant&>(lvalue));
            }
        }
        else {
            reset();
            if (lvalue.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, moveConstructor, static_cast<Variant&>(lvalue));
            }
            d_type = lvalue.d_type;
        }
    }
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03>& Variant_Base<t_HEAD,
                                                t_TAIL_01,
                                                t_TAIL_02,
                                                t_TAIL_03,
                                                BSLS_COMPILERFEATURES_FILLT(15)
                                                >::operator=(
                              BloombergLP::bslmf::MovableRef<Variant_Base> rhs)
{
    Variant_Base& lvalue = rhs;
    if (&lvalue != this) {
        if (this->d_type == lvalue.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_MoveAssignVisitor<Variant>
                moveAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, moveAssign, static_cast<Variant&>(lvalue));
            }
        }
        else {
            reset();
            if (lvalue.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, moveConstructor, static_cast<Variant&>(lvalue));
            }
            d_type = lvalue.d_type;
        }
    }
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04>& Variant_Base<t_HEAD,
                                                t_TAIL_01,
                                                t_TAIL_02,
                                                t_TAIL_03,
                                                t_TAIL_04,
                                                BSLS_COMPILERFEATURES_FILLT(14)
                                                >::operator=(
                              BloombergLP::bslmf::MovableRef<Variant_Base> rhs)
{
    Variant_Base& lvalue = rhs;
    if (&lvalue != this) {
        if (this->d_type == lvalue.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_MoveAssignVisitor<Variant>
                moveAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, moveAssign, static_cast<Variant&>(lvalue));
            }
        }
        else {
            reset();
            if (lvalue.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, moveConstructor, static_cast<Variant&>(lvalue));
            }
            d_type = lvalue.d_type;
        }
    }
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05>& Variant_Base<t_HEAD,
                                                t_TAIL_01,
                                                t_TAIL_02,
                                                t_TAIL_03,
                                                t_TAIL_04,
                                                t_TAIL_05,
                                                BSLS_COMPILERFEATURES_FILLT(13)
                                                >::operator=(
                              BloombergLP::bslmf::MovableRef<Variant_Base> rhs)
{
    Variant_Base& lvalue = rhs;
    if (&lvalue != this) {
        if (this->d_type == lvalue.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_MoveAssignVisitor<Variant>
                moveAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, moveAssign, static_cast<Variant&>(lvalue));
            }
        }
        else {
            reset();
            if (lvalue.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, moveConstructor, static_cast<Variant&>(lvalue));
            }
            d_type = lvalue.d_type;
        }
    }
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06>& Variant_Base<t_HEAD,
                                                t_TAIL_01,
                                                t_TAIL_02,
                                                t_TAIL_03,
                                                t_TAIL_04,
                                                t_TAIL_05,
                                                t_TAIL_06,
                                                BSLS_COMPILERFEATURES_FILLT(12)
                                                >::operator=(
                              BloombergLP::bslmf::MovableRef<Variant_Base> rhs)
{
    Variant_Base& lvalue = rhs;
    if (&lvalue != this) {
        if (this->d_type == lvalue.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_MoveAssignVisitor<Variant>
                moveAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, moveAssign, static_cast<Variant&>(lvalue));
            }
        }
        else {
            reset();
            if (lvalue.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, moveConstructor, static_cast<Variant&>(lvalue));
            }
            d_type = lvalue.d_type;
        }
    }
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07>& Variant_Base<t_HEAD,
                                                t_TAIL_01,
                                                t_TAIL_02,
                                                t_TAIL_03,
                                                t_TAIL_04,
                                                t_TAIL_05,
                                                t_TAIL_06,
                                                t_TAIL_07,
                                                BSLS_COMPILERFEATURES_FILLT(11)
                                                >::operator=(
                              BloombergLP::bslmf::MovableRef<Variant_Base> rhs)
{
    Variant_Base& lvalue = rhs;
    if (&lvalue != this) {
        if (this->d_type == lvalue.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_MoveAssignVisitor<Variant>
                moveAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, moveAssign, static_cast<Variant&>(lvalue));
            }
        }
        else {
            reset();
            if (lvalue.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, moveConstructor, static_cast<Variant&>(lvalue));
            }
            d_type = lvalue.d_type;
        }
    }
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08>& Variant_Base<t_HEAD,
                                                t_TAIL_01,
                                                t_TAIL_02,
                                                t_TAIL_03,
                                                t_TAIL_04,
                                                t_TAIL_05,
                                                t_TAIL_06,
                                                t_TAIL_07,
                                                t_TAIL_08,
                                                BSLS_COMPILERFEATURES_FILLT(10)
                                                >::operator=(
                              BloombergLP::bslmf::MovableRef<Variant_Base> rhs)
{
    Variant_Base& lvalue = rhs;
    if (&lvalue != this) {
        if (this->d_type == lvalue.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_MoveAssignVisitor<Variant>
                moveAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, moveAssign, static_cast<Variant&>(lvalue));
            }
        }
        else {
            reset();
            if (lvalue.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, moveConstructor, static_cast<Variant&>(lvalue));
            }
            d_type = lvalue.d_type;
        }
    }
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09>& Variant_Base<t_HEAD,
                                                t_TAIL_01,
                                                t_TAIL_02,
                                                t_TAIL_03,
                                                t_TAIL_04,
                                                t_TAIL_05,
                                                t_TAIL_06,
                                                t_TAIL_07,
                                                t_TAIL_08,
                                                t_TAIL_09,
                                                BSLS_COMPILERFEATURES_FILLT( 9)
                                                >::operator=(
                              BloombergLP::bslmf::MovableRef<Variant_Base> rhs)
{
    Variant_Base& lvalue = rhs;
    if (&lvalue != this) {
        if (this->d_type == lvalue.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_MoveAssignVisitor<Variant>
                moveAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, moveAssign, static_cast<Variant&>(lvalue));
            }
        }
        else {
            reset();
            if (lvalue.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, moveConstructor, static_cast<Variant&>(lvalue));
            }
            d_type = lvalue.d_type;
        }
    }
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10>& Variant_Base<t_HEAD,
                                                t_TAIL_01,
                                                t_TAIL_02,
                                                t_TAIL_03,
                                                t_TAIL_04,
                                                t_TAIL_05,
                                                t_TAIL_06,
                                                t_TAIL_07,
                                                t_TAIL_08,
                                                t_TAIL_09,
                                                t_TAIL_10,
                                                BSLS_COMPILERFEATURES_FILLT( 8)
                                                >::operator=(
                              BloombergLP::bslmf::MovableRef<Variant_Base> rhs)
{
    Variant_Base& lvalue = rhs;
    if (&lvalue != this) {
        if (this->d_type == lvalue.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_MoveAssignVisitor<Variant>
                moveAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, moveAssign, static_cast<Variant&>(lvalue));
            }
        }
        else {
            reset();
            if (lvalue.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, moveConstructor, static_cast<Variant&>(lvalue));
            }
            d_type = lvalue.d_type;
        }
    }
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11>& Variant_Base<t_HEAD,
                                                t_TAIL_01,
                                                t_TAIL_02,
                                                t_TAIL_03,
                                                t_TAIL_04,
                                                t_TAIL_05,
                                                t_TAIL_06,
                                                t_TAIL_07,
                                                t_TAIL_08,
                                                t_TAIL_09,
                                                t_TAIL_10,
                                                t_TAIL_11,
                                                BSLS_COMPILERFEATURES_FILLT( 7)
                                                >::operator=(
                              BloombergLP::bslmf::MovableRef<Variant_Base> rhs)
{
    Variant_Base& lvalue = rhs;
    if (&lvalue != this) {
        if (this->d_type == lvalue.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_MoveAssignVisitor<Variant>
                moveAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, moveAssign, static_cast<Variant&>(lvalue));
            }
        }
        else {
            reset();
            if (lvalue.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, moveConstructor, static_cast<Variant&>(lvalue));
            }
            d_type = lvalue.d_type;
        }
    }
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12>& Variant_Base<t_HEAD,
                                                t_TAIL_01,
                                                t_TAIL_02,
                                                t_TAIL_03,
                                                t_TAIL_04,
                                                t_TAIL_05,
                                                t_TAIL_06,
                                                t_TAIL_07,
                                                t_TAIL_08,
                                                t_TAIL_09,
                                                t_TAIL_10,
                                                t_TAIL_11,
                                                t_TAIL_12,
                                                BSLS_COMPILERFEATURES_FILLT( 6)
                                                >::operator=(
                              BloombergLP::bslmf::MovableRef<Variant_Base> rhs)
{
    Variant_Base& lvalue = rhs;
    if (&lvalue != this) {
        if (this->d_type == lvalue.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_MoveAssignVisitor<Variant>
                moveAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, moveAssign, static_cast<Variant&>(lvalue));
            }
        }
        else {
            reset();
            if (lvalue.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, moveConstructor, static_cast<Variant&>(lvalue));
            }
            d_type = lvalue.d_type;
        }
    }
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13>& Variant_Base<t_HEAD,
                                                t_TAIL_01,
                                                t_TAIL_02,
                                                t_TAIL_03,
                                                t_TAIL_04,
                                                t_TAIL_05,
                                                t_TAIL_06,
                                                t_TAIL_07,
                                                t_TAIL_08,
                                                t_TAIL_09,
                                                t_TAIL_10,
                                                t_TAIL_11,
                                                t_TAIL_12,
                                                t_TAIL_13,
                                                BSLS_COMPILERFEATURES_FILLT( 5)
                                                >::operator=(
                              BloombergLP::bslmf::MovableRef<Variant_Base> rhs)
{
    Variant_Base& lvalue = rhs;
    if (&lvalue != this) {
        if (this->d_type == lvalue.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_MoveAssignVisitor<Variant>
                moveAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, moveAssign, static_cast<Variant&>(lvalue));
            }
        }
        else {
            reset();
            if (lvalue.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, moveConstructor, static_cast<Variant&>(lvalue));
            }
            d_type = lvalue.d_type;
        }
    }
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14>& Variant_Base<t_HEAD,
                                                t_TAIL_01,
                                                t_TAIL_02,
                                                t_TAIL_03,
                                                t_TAIL_04,
                                                t_TAIL_05,
                                                t_TAIL_06,
                                                t_TAIL_07,
                                                t_TAIL_08,
                                                t_TAIL_09,
                                                t_TAIL_10,
                                                t_TAIL_11,
                                                t_TAIL_12,
                                                t_TAIL_13,
                                                t_TAIL_14,
                                                BSLS_COMPILERFEATURES_FILLT( 4)
                                                >::operator=(
                              BloombergLP::bslmf::MovableRef<Variant_Base> rhs)
{
    Variant_Base& lvalue = rhs;
    if (&lvalue != this) {
        if (this->d_type == lvalue.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_MoveAssignVisitor<Variant>
                moveAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, moveAssign, static_cast<Variant&>(lvalue));
            }
        }
        else {
            reset();
            if (lvalue.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, moveConstructor, static_cast<Variant&>(lvalue));
            }
            d_type = lvalue.d_type;
        }
    }
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15>& Variant_Base<t_HEAD,
                                                t_TAIL_01,
                                                t_TAIL_02,
                                                t_TAIL_03,
                                                t_TAIL_04,
                                                t_TAIL_05,
                                                t_TAIL_06,
                                                t_TAIL_07,
                                                t_TAIL_08,
                                                t_TAIL_09,
                                                t_TAIL_10,
                                                t_TAIL_11,
                                                t_TAIL_12,
                                                t_TAIL_13,
                                                t_TAIL_14,
                                                t_TAIL_15,
                                                BSLS_COMPILERFEATURES_FILLT( 3)
                                                >::operator=(
                              BloombergLP::bslmf::MovableRef<Variant_Base> rhs)
{
    Variant_Base& lvalue = rhs;
    if (&lvalue != this) {
        if (this->d_type == lvalue.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_MoveAssignVisitor<Variant>
                moveAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, moveAssign, static_cast<Variant&>(lvalue));
            }
        }
        else {
            reset();
            if (lvalue.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, moveConstructor, static_cast<Variant&>(lvalue));
            }
            d_type = lvalue.d_type;
        }
    }
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16>& Variant_Base<t_HEAD,
                                                t_TAIL_01,
                                                t_TAIL_02,
                                                t_TAIL_03,
                                                t_TAIL_04,
                                                t_TAIL_05,
                                                t_TAIL_06,
                                                t_TAIL_07,
                                                t_TAIL_08,
                                                t_TAIL_09,
                                                t_TAIL_10,
                                                t_TAIL_11,
                                                t_TAIL_12,
                                                t_TAIL_13,
                                                t_TAIL_14,
                                                t_TAIL_15,
                                                t_TAIL_16,
                                                BSLS_COMPILERFEATURES_FILLT( 2)
                                                >::operator=(
                              BloombergLP::bslmf::MovableRef<Variant_Base> rhs)
{
    Variant_Base& lvalue = rhs;
    if (&lvalue != this) {
        if (this->d_type == lvalue.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_MoveAssignVisitor<Variant>
                moveAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, moveAssign, static_cast<Variant&>(lvalue));
            }
        }
        else {
            reset();
            if (lvalue.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, moveConstructor, static_cast<Variant&>(lvalue));
            }
            d_type = lvalue.d_type;
        }
    }
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17>& Variant_Base<t_HEAD,
                                                t_TAIL_01,
                                                t_TAIL_02,
                                                t_TAIL_03,
                                                t_TAIL_04,
                                                t_TAIL_05,
                                                t_TAIL_06,
                                                t_TAIL_07,
                                                t_TAIL_08,
                                                t_TAIL_09,
                                                t_TAIL_10,
                                                t_TAIL_11,
                                                t_TAIL_12,
                                                t_TAIL_13,
                                                t_TAIL_14,
                                                t_TAIL_15,
                                                t_TAIL_16,
                                                t_TAIL_17,
                                                BSLS_COMPILERFEATURES_FILLT( 1)
                                                >::operator=(
                              BloombergLP::bslmf::MovableRef<Variant_Base> rhs)
{
    Variant_Base& lvalue = rhs;
    if (&lvalue != this) {
        if (this->d_type == lvalue.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_MoveAssignVisitor<Variant>
                moveAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, moveAssign, static_cast<Variant&>(lvalue));
            }
        }
        else {
            reset();
            if (lvalue.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, moveConstructor, static_cast<Variant&>(lvalue));
            }
            d_type = lvalue.d_type;
        }
    }
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     t_TAIL_18>& Variant_Base<t_HEAD,
                                                t_TAIL_01,
                                                t_TAIL_02,
                                                t_TAIL_03,
                                                t_TAIL_04,
                                                t_TAIL_05,
                                                t_TAIL_06,
                                                t_TAIL_07,
                                                t_TAIL_08,
                                                t_TAIL_09,
                                                t_TAIL_10,
                                                t_TAIL_11,
                                                t_TAIL_12,
                                                t_TAIL_13,
                                                t_TAIL_14,
                                                t_TAIL_15,
                                                t_TAIL_16,
                                                t_TAIL_17,
                                                t_TAIL_18,
                                                BSLS_COMPILERFEATURES_FILLT( 0)
                                                >::operator=(
                              BloombergLP::bslmf::MovableRef<Variant_Base> rhs)
{
    Variant_Base& lvalue = rhs;
    if (&lvalue != this) {
        if (this->d_type == lvalue.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_MoveAssignVisitor<Variant>
                moveAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, moveAssign, static_cast<Variant&>(lvalue));
            }
        }
        else {
            reset();
            if (lvalue.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, moveConstructor, static_cast<Variant&>(lvalue));
            }
            d_type = lvalue.d_type;
        }
    }
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 18
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 0
template <class t_HEAD>
void Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                          >::reset() BSLS_KEYWORD_NOEXCEPT
{
    if (d_type != bsl::variant_npos) {
        BloombergLP::bslstl::Variant_DestructorVisitor destructor;
        bsl::visit(destructor, static_cast<Variant&>(*this));
        d_type = bsl::variant_npos;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 1
template <class t_HEAD, class t_TAIL_01>
void Variant_Base<t_HEAD, t_TAIL_01,
                          BSLS_COMPILERFEATURES_FILLT(17)
                          >::reset() BSLS_KEYWORD_NOEXCEPT
{
    if (d_type != bsl::variant_npos) {
        BloombergLP::bslstl::Variant_DestructorVisitor destructor;
        bsl::visit(destructor, static_cast<Variant&>(*this));
        d_type = bsl::variant_npos;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          BSLS_COMPILERFEATURES_FILLT(16)
                          >::reset() BSLS_KEYWORD_NOEXCEPT
{
    if (d_type != bsl::variant_npos) {
        BloombergLP::bslstl::Variant_DestructorVisitor destructor;
        bsl::visit(destructor, static_cast<Variant&>(*this));
        d_type = bsl::variant_npos;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          BSLS_COMPILERFEATURES_FILLT(15)
                          >::reset() BSLS_KEYWORD_NOEXCEPT
{
    if (d_type != bsl::variant_npos) {
        BloombergLP::bslstl::Variant_DestructorVisitor destructor;
        bsl::visit(destructor, static_cast<Variant&>(*this));
        d_type = bsl::variant_npos;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          BSLS_COMPILERFEATURES_FILLT(14)
                          >::reset() BSLS_KEYWORD_NOEXCEPT
{
    if (d_type != bsl::variant_npos) {
        BloombergLP::bslstl::Variant_DestructorVisitor destructor;
        bsl::visit(destructor, static_cast<Variant&>(*this));
        d_type = bsl::variant_npos;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          BSLS_COMPILERFEATURES_FILLT(13)
                          >::reset() BSLS_KEYWORD_NOEXCEPT
{
    if (d_type != bsl::variant_npos) {
        BloombergLP::bslstl::Variant_DestructorVisitor destructor;
        bsl::visit(destructor, static_cast<Variant&>(*this));
        d_type = bsl::variant_npos;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          BSLS_COMPILERFEATURES_FILLT(12)
                          >::reset() BSLS_KEYWORD_NOEXCEPT
{
    if (d_type != bsl::variant_npos) {
        BloombergLP::bslstl::Variant_DestructorVisitor destructor;
        bsl::visit(destructor, static_cast<Variant&>(*this));
        d_type = bsl::variant_npos;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          BSLS_COMPILERFEATURES_FILLT(11)
                          >::reset() BSLS_KEYWORD_NOEXCEPT
{
    if (d_type != bsl::variant_npos) {
        BloombergLP::bslstl::Variant_DestructorVisitor destructor;
        bsl::visit(destructor, static_cast<Variant&>(*this));
        d_type = bsl::variant_npos;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          BSLS_COMPILERFEATURES_FILLT(10)
                          >::reset() BSLS_KEYWORD_NOEXCEPT
{
    if (d_type != bsl::variant_npos) {
        BloombergLP::bslstl::Variant_DestructorVisitor destructor;
        bsl::visit(destructor, static_cast<Variant&>(*this));
        d_type = bsl::variant_npos;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          BSLS_COMPILERFEATURES_FILLT( 9)
                          >::reset() BSLS_KEYWORD_NOEXCEPT
{
    if (d_type != bsl::variant_npos) {
        BloombergLP::bslstl::Variant_DestructorVisitor destructor;
        bsl::visit(destructor, static_cast<Variant&>(*this));
        d_type = bsl::variant_npos;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          BSLS_COMPILERFEATURES_FILLT( 8)
                          >::reset() BSLS_KEYWORD_NOEXCEPT
{
    if (d_type != bsl::variant_npos) {
        BloombergLP::bslstl::Variant_DestructorVisitor destructor;
        bsl::visit(destructor, static_cast<Variant&>(*this));
        d_type = bsl::variant_npos;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          BSLS_COMPILERFEATURES_FILLT( 7)
                          >::reset() BSLS_KEYWORD_NOEXCEPT
{
    if (d_type != bsl::variant_npos) {
        BloombergLP::bslstl::Variant_DestructorVisitor destructor;
        bsl::visit(destructor, static_cast<Variant&>(*this));
        d_type = bsl::variant_npos;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          BSLS_COMPILERFEATURES_FILLT( 6)
                          >::reset() BSLS_KEYWORD_NOEXCEPT
{
    if (d_type != bsl::variant_npos) {
        BloombergLP::bslstl::Variant_DestructorVisitor destructor;
        bsl::visit(destructor, static_cast<Variant&>(*this));
        d_type = bsl::variant_npos;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          BSLS_COMPILERFEATURES_FILLT( 5)
                          >::reset() BSLS_KEYWORD_NOEXCEPT
{
    if (d_type != bsl::variant_npos) {
        BloombergLP::bslstl::Variant_DestructorVisitor destructor;
        bsl::visit(destructor, static_cast<Variant&>(*this));
        d_type = bsl::variant_npos;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          BSLS_COMPILERFEATURES_FILLT( 4)
                          >::reset() BSLS_KEYWORD_NOEXCEPT
{
    if (d_type != bsl::variant_npos) {
        BloombergLP::bslstl::Variant_DestructorVisitor destructor;
        bsl::visit(destructor, static_cast<Variant&>(*this));
        d_type = bsl::variant_npos;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          BSLS_COMPILERFEATURES_FILLT( 3)
                          >::reset() BSLS_KEYWORD_NOEXCEPT
{
    if (d_type != bsl::variant_npos) {
        BloombergLP::bslstl::Variant_DestructorVisitor destructor;
        bsl::visit(destructor, static_cast<Variant&>(*this));
        d_type = bsl::variant_npos;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          t_TAIL_16,
                          BSLS_COMPILERFEATURES_FILLT( 2)
                          >::reset() BSLS_KEYWORD_NOEXCEPT
{
    if (d_type != bsl::variant_npos) {
        BloombergLP::bslstl::Variant_DestructorVisitor destructor;
        bsl::visit(destructor, static_cast<Variant&>(*this));
        d_type = bsl::variant_npos;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          t_TAIL_16,
                          t_TAIL_17,
                          BSLS_COMPILERFEATURES_FILLT( 1)
                          >::reset() BSLS_KEYWORD_NOEXCEPT
{
    if (d_type != bsl::variant_npos) {
        BloombergLP::bslstl::Variant_DestructorVisitor destructor;
        bsl::visit(destructor, static_cast<Variant&>(*this));
        d_type = bsl::variant_npos;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
void Variant_Base<t_HEAD, t_TAIL_01,
                          t_TAIL_02,
                          t_TAIL_03,
                          t_TAIL_04,
                          t_TAIL_05,
                          t_TAIL_06,
                          t_TAIL_07,
                          t_TAIL_08,
                          t_TAIL_09,
                          t_TAIL_10,
                          t_TAIL_11,
                          t_TAIL_12,
                          t_TAIL_13,
                          t_TAIL_14,
                          t_TAIL_15,
                          t_TAIL_16,
                          t_TAIL_17,
                          t_TAIL_18,
                          BSLS_COMPILERFEATURES_FILLT( 0)
                          >::reset() BSLS_KEYWORD_NOEXCEPT
{
    if (d_type != bsl::variant_npos) {
        BloombergLP::bslstl::Variant_DestructorVisitor destructor;
        bsl::visit(destructor, static_cast<Variant&>(*this));
        d_type = bsl::variant_npos;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 18
 
#else
// The generated code below is a workaround for the absence of perfect
// forwarding in some compilers.
template <class t_HEAD, class... t_TAIL>
inline
Variant_Base<t_HEAD, t_TAIL...>& Variant_Base<t_HEAD, t_TAIL...>::operator=(
                                                       const Variant_Base& rhs)
{
    if (&rhs != this) {
        if (this->d_type == rhs.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_CopyAssignVisitor<Variant>
                copyAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, copyAssign, static_cast<const Variant&>(rhs));
            }
        }
        else {
            reset();
            if (rhs.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_CopyConstructVisitor<Variant_Base>
                    copyConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, copyConstructor, static_cast<const Variant&>(rhs));
            }
            d_type = rhs.d_type;
        }
    }
    return *this;
}
 
template <class t_HEAD, class... t_TAIL>
inline
Variant_Base<t_HEAD, t_TAIL...>& Variant_Base<t_HEAD, t_TAIL...>::operator=(
                              BloombergLP::bslmf::MovableRef<Variant_Base> rhs)
{
    Variant_Base& lvalue = rhs;
    if (&lvalue != this) {
        if (this->d_type == lvalue.d_type) {
            if (d_type != bsl::variant_npos) {
                Variant& self = static_cast<Variant&>(*this);
                BloombergLP::bslstl::Variant_MoveAssignVisitor<Variant>
                moveAssign(BSLS_UTIL_ADDRESSOF(self));
                BSLSTL_VARIANT_VISITID(
                    void, moveAssign, static_cast<Variant&>(lvalue));
            }
        }
        else {
            reset();
            if (lvalue.d_type != bsl::variant_npos) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(
                    void, moveConstructor, static_cast<Variant&>(lvalue));
            }
            d_type = lvalue.d_type;
        }
    }
    return *this;
}
template <class t_HEAD, class... t_TAIL>
void Variant_Base<t_HEAD, t_TAIL...>::reset() BSLS_KEYWORD_NOEXCEPT
{
    if (d_type != bsl::variant_npos) {
        BloombergLP::bslstl::Variant_DestructorVisitor destructor;
        bsl::visit(destructor, static_cast<Variant&>(*this));
        d_type = bsl::variant_npos;
    }
}
// }}} END GENERATED CODE
#endif
}  // close package namespace
 
 
namespace bsl {
 
                               // -------------
                               // class variant
                               // -------------
 
// CREATORS
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
template <class t_HEAD, class... t_TAIL>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL...>::variant(
    t_TYPE&& value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      std::forward<t_TYPE>(value))
{
}
 
template <class t_HEAD, class... t_TAIL>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL...>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    t_TYPE&&       value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t{},
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      std::forward<t_TYPE>(value))
{
}
#else  // BSL_VARIANT_FULL_IMPLEMENTATION
#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
// {{{ BEGIN GENERATED CODE
// Command line: sim_cpp11_features.pl bslstl_variant.h
#ifndef BSLSTL_VARIANT_VARIADIC_LIMIT
#define BSLSTL_VARIANT_VARIADIC_LIMIT 18
#endif
#ifndef BSLSTL_VARIANT_VARIADIC_LIMIT_P
#define BSLSTL_VARIANT_VARIADIC_LIMIT_P BSLSTL_VARIANT_VARIADIC_LIMIT
#endif
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant()
: Variant_Base()
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant()
: Variant_Base()
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant()
: Variant_Base()
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant()
: Variant_Base()
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant()
: Variant_Base()
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant()
: Variant_Base()
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant()
: Variant_Base()
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant()
: Variant_Base()
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant()
: Variant_Base()
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant()
: Variant_Base()
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant()
: Variant_Base()
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant()
: Variant_Base()
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant()
: Variant_Base()
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant()
: Variant_Base()
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant()
: Variant_Base()
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant()
: Variant_Base()
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant()
: Variant_Base()
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant()
: Variant_Base()
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant()
: Variant_Base()
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                >::variant(const variant& original)
: Variant_Base(original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)
                >::variant(const variant& original)
: Variant_Base(original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)
                >::variant(const variant& original)
: Variant_Base(original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)
                >::variant(const variant& original)
: Variant_Base(original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)
                >::variant(const variant& original)
: Variant_Base(original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)
                >::variant(const variant& original)
: Variant_Base(original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)
                >::variant(const variant& original)
: Variant_Base(original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)
                >::variant(const variant& original)
: Variant_Base(original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)
                >::variant(const variant& original)
: Variant_Base(original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)
                >::variant(const variant& original)
: Variant_Base(original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)
                >::variant(const variant& original)
: Variant_Base(original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)
                >::variant(const variant& original)
: Variant_Base(original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)
                >::variant(const variant& original)
: Variant_Base(original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)
                >::variant(const variant& original)
: Variant_Base(original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)
                >::variant(const variant& original)
: Variant_Base(original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)
                >::variant(const variant& original)
: Variant_Base(original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)
                >::variant(const variant& original)
: Variant_Base(original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)
                >::variant(const variant& original)
: Variant_Base(original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)
                >::variant(const variant& original)
: Variant_Base(original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(
                              BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(
                              BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(
                              BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(
                              BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(
                              BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(
                              BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(
                              BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(
                              BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(
                              BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(
                              BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(
                              BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(
                              BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(
                              BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(
                              BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(
                              BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(
                              BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(
                              BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(
                              BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(
                              BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <class t_TYPE>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(
    const t_TYPE& value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(
    const t_TYPE& value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(
    const t_TYPE& value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(
    const t_TYPE& value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(
    const t_TYPE& value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(
    const t_TYPE& value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(
    const t_TYPE& value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(
    const t_TYPE& value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(
    const t_TYPE& value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(
    const t_TYPE& value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(
    const t_TYPE& value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(
    const t_TYPE& value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(
    const t_TYPE& value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(
    const t_TYPE& value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(
    const t_TYPE& value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(
    const t_TYPE& value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(
    const t_TYPE& value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(
    const t_TYPE& value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(
    const t_TYPE& value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <class t_TYPE>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <size_t t_INDEX>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                >::variant(bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::in_place_index_t<t_INDEX>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)
                >::variant(bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::in_place_index_t<t_INDEX>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)
                >::variant(bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::in_place_index_t<t_INDEX>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)
                >::variant(bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::in_place_index_t<t_INDEX>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)
                >::variant(bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::in_place_index_t<t_INDEX>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)
                >::variant(bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::in_place_index_t<t_INDEX>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)
                >::variant(bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::in_place_index_t<t_INDEX>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)
                >::variant(bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::in_place_index_t<t_INDEX>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)
                >::variant(bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::in_place_index_t<t_INDEX>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)
                >::variant(bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::in_place_index_t<t_INDEX>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)
                >::variant(bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::in_place_index_t<t_INDEX>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)
                >::variant(bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::in_place_index_t<t_INDEX>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)
                >::variant(bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::in_place_index_t<t_INDEX>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)
                >::variant(bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::in_place_index_t<t_INDEX>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)
                >::variant(bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::in_place_index_t<t_INDEX>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)
                >::variant(bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::in_place_index_t<t_INDEX>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)
                >::variant(bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::in_place_index_t<t_INDEX>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)
                >::variant(bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::in_place_index_t<t_INDEX>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)
                >::variant(bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::in_place_index_t<t_INDEX>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02,
                                    const t_ARG_03&                arg_03)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02, arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02,
                                    const t_ARG_03&                arg_03)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02, arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02,
                                    const t_ARG_03&                arg_03)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02, arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02,
                                    const t_ARG_03&                arg_03)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02, arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02,
                                    const t_ARG_03&                arg_03)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02, arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02,
                                    const t_ARG_03&                arg_03)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02, arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02,
                                    const t_ARG_03&                arg_03)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02, arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02,
                                    const t_ARG_03&                arg_03)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02, arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02,
                                    const t_ARG_03&                arg_03)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02, arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02,
                                    const t_ARG_03&                arg_03)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02, arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02,
                                    const t_ARG_03&                arg_03)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02, arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02,
                                    const t_ARG_03&                arg_03)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02, arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02,
                                    const t_ARG_03&                arg_03)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02, arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02,
                                    const t_ARG_03&                arg_03)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02, arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02,
                                    const t_ARG_03&                arg_03)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02, arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02,
                                    const t_ARG_03&                arg_03)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02, arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02,
                                    const t_ARG_03&                arg_03)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02, arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02,
                                    const t_ARG_03&                arg_03)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02, arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02,
                                    const t_ARG_03&                arg_03)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02, arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)
                >::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator)
: Variant_Base(bsl::allocator_arg_t(), allocator)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator)
: Variant_Base(bsl::allocator_arg_t(), allocator)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator)
: Variant_Base(bsl::allocator_arg_t(), allocator)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator)
: Variant_Base(bsl::allocator_arg_t(), allocator)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator)
: Variant_Base(bsl::allocator_arg_t(), allocator)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator)
: Variant_Base(bsl::allocator_arg_t(), allocator)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator)
: Variant_Base(bsl::allocator_arg_t(), allocator)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator)
: Variant_Base(bsl::allocator_arg_t(), allocator)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator)
: Variant_Base(bsl::allocator_arg_t(), allocator)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator)
: Variant_Base(bsl::allocator_arg_t(), allocator)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator)
: Variant_Base(bsl::allocator_arg_t(), allocator)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator)
: Variant_Base(bsl::allocator_arg_t(), allocator)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator)
: Variant_Base(bsl::allocator_arg_t(), allocator)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator)
: Variant_Base(bsl::allocator_arg_t(), allocator)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator)
: Variant_Base(bsl::allocator_arg_t(), allocator)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator)
: Variant_Base(bsl::allocator_arg_t(), allocator)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator)
: Variant_Base(bsl::allocator_arg_t(), allocator)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator)
: Variant_Base(bsl::allocator_arg_t(), allocator)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator)
: Variant_Base(bsl::allocator_arg_t(), allocator)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator,
                                    const variant&       original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator,
                                    const variant&       original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator,
                                    const variant&       original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator,
                                    const variant&       original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator,
                                    const variant&       original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator,
                                    const variant&       original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator,
                                    const variant&       original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator,
                                    const variant&       original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator,
                                    const variant&       original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator,
                                    const variant&       original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator,
                                    const variant&       original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator,
                                    const variant&       original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator,
                                    const variant&       original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator,
                                    const variant&       original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator,
                                    const variant&       original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator,
                                    const variant&       original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator,
                                    const variant&       original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator,
                                    const variant&       original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator,
                                    const variant&       original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <class t_TYPE>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    const t_TYPE&  value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    const t_TYPE&  value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    const t_TYPE&  value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    const t_TYPE&  value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    const t_TYPE&  value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    const t_TYPE&  value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    const t_TYPE&  value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    const t_TYPE&  value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    const t_TYPE&  value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    const t_TYPE&  value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    const t_TYPE&  value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    const t_TYPE&  value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    const t_TYPE&  value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    const t_TYPE&  value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    const t_TYPE&  value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    const t_TYPE&  value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    const t_TYPE&  value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    const t_TYPE&  value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    const t_TYPE&  value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <class t_TYPE>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <size_t t_INDEX>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>())
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <class t_TYPE>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD> >::value,
                        t_TYPE&>::type
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::emplace()
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>();
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <class t_TYPE>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::emplace()
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>();
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <class t_TYPE>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::emplace()
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>();
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <class t_TYPE>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::emplace()
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>();
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <class t_TYPE>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::emplace()
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>();
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <class t_TYPE>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::emplace()
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>();
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <class t_TYPE>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::emplace()
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>();
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <class t_TYPE>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::emplace()
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>();
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <class t_TYPE>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::emplace()
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>();
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <class t_TYPE>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::emplace()
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>();
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <class t_TYPE>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::emplace()
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>();
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <class t_TYPE>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::emplace()
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>();
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <class t_TYPE>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::emplace()
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>();
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <class t_TYPE>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::emplace()
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>();
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <class t_TYPE>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::emplace()
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>();
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <class t_TYPE>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::emplace()
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>();
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <class t_TYPE>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::emplace()
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>();
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <class t_TYPE>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16,
                                            t_TAIL_17> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::emplace()
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>();
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <class t_TYPE>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16,
                                            t_TAIL_17,
                                            t_TAIL_18> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::emplace()
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>();
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <class t_TYPE, class t_ARG_01>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD> >::value,
                        t_TYPE&>::type
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                >::emplace(const t_ARG_01& arg_01)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <class t_TYPE, class t_ARG_01>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)
                >::emplace(const t_ARG_01& arg_01)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <class t_TYPE, class t_ARG_01>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)
                >::emplace(const t_ARG_01& arg_01)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <class t_TYPE, class t_ARG_01>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)
                >::emplace(const t_ARG_01& arg_01)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <class t_TYPE, class t_ARG_01>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)
                >::emplace(const t_ARG_01& arg_01)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <class t_TYPE, class t_ARG_01>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)
                >::emplace(const t_ARG_01& arg_01)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <class t_TYPE, class t_ARG_01>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)
                >::emplace(const t_ARG_01& arg_01)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <class t_TYPE, class t_ARG_01>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)
                >::emplace(const t_ARG_01& arg_01)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <class t_TYPE, class t_ARG_01>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)
                >::emplace(const t_ARG_01& arg_01)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <class t_TYPE, class t_ARG_01>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)
                >::emplace(const t_ARG_01& arg_01)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <class t_TYPE, class t_ARG_01>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)
                >::emplace(const t_ARG_01& arg_01)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <class t_TYPE, class t_ARG_01>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)
                >::emplace(const t_ARG_01& arg_01)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <class t_TYPE, class t_ARG_01>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)
                >::emplace(const t_ARG_01& arg_01)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <class t_TYPE, class t_ARG_01>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)
                >::emplace(const t_ARG_01& arg_01)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <class t_TYPE, class t_ARG_01>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)
                >::emplace(const t_ARG_01& arg_01)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <class t_TYPE, class t_ARG_01>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)
                >::emplace(const t_ARG_01& arg_01)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <class t_TYPE, class t_ARG_01>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)
                >::emplace(const t_ARG_01& arg_01)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <class t_TYPE, class t_ARG_01>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16,
                                            t_TAIL_17> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)
                >::emplace(const t_ARG_01& arg_01)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <class t_TYPE, class t_ARG_01>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16,
                                            t_TAIL_17,
                                            t_TAIL_18> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)
                >::emplace(const t_ARG_01& arg_01)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD> >::value,
                        t_TYPE&>::type
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16,
                                            t_TAIL_17> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16,
                                            t_TAIL_17,
                                            t_TAIL_18> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD> >::value,
                        t_TYPE&>::type
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16,
                                            t_TAIL_17> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16,
                                            t_TAIL_17,
                                            t_TAIL_18> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD> >::value,
                        t_TYPE&>::type
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16,
                                            t_TAIL_17> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16,
                                            t_TAIL_17,
                                            t_TAIL_18> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD> >::value,
                        t_TYPE&>::type
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16,
                                            t_TAIL_17> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16,
                                            t_TAIL_17,
                                            t_TAIL_18> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD> >::value,
                        t_TYPE&>::type
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16,
                                            t_TAIL_17> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16,
                                            t_TAIL_17,
                                            t_TAIL_18> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD> >::value,
                        t_TYPE&>::type
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16,
                                            t_TAIL_17> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16,
                                            t_TAIL_17,
                                            t_TAIL_18> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD> >::value,
                        t_TYPE&>::type
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16,
                                            t_TAIL_17> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16,
                                            t_TAIL_17,
                                            t_TAIL_18> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD> >::value,
                        t_TYPE&>::type
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16,
                                            t_TAIL_17> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16,
                                            t_TAIL_17,
                                            t_TAIL_18> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD> >::value,
                        t_TYPE&>::type
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09,
                                              arg_10);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09,
                                              arg_10);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09,
                                              arg_10);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09,
                                              arg_10);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09,
                                              arg_10);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09,
                                              arg_10);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09,
                                              arg_10);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09,
                                              arg_10);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09,
                                              arg_10);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09,
                                              arg_10);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09,
                                              arg_10);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09,
                                              arg_10);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09,
                                              arg_10);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09,
                                              arg_10);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09,
                                              arg_10);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09,
                                              arg_10);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09,
                                              arg_10);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16,
                                            t_TAIL_17> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09,
                                              arg_10);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16,
                                            t_TAIL_17,
                                            t_TAIL_18> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09,
                                              arg_10);
 
    return bsl::get<index>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <size_t t_INDEX>
typename variant_alternative<t_INDEX, variant<t_HEAD> >::type&
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::emplace()
{
    Variant_Base::template baseEmplace<t_INDEX>();
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01> >::type&
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::emplace()
{
    Variant_Base::template baseEmplace<t_INDEX>();
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::emplace()
{
    Variant_Base::template baseEmplace<t_INDEX>();
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::emplace()
{
    Variant_Base::template baseEmplace<t_INDEX>();
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::emplace()
{
    Variant_Base::template baseEmplace<t_INDEX>();
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::emplace()
{
    Variant_Base::template baseEmplace<t_INDEX>();
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::emplace()
{
    Variant_Base::template baseEmplace<t_INDEX>();
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::emplace()
{
    Variant_Base::template baseEmplace<t_INDEX>();
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::emplace()
{
    Variant_Base::template baseEmplace<t_INDEX>();
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::emplace()
{
    Variant_Base::template baseEmplace<t_INDEX>();
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::emplace()
{
    Variant_Base::template baseEmplace<t_INDEX>();
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::emplace()
{
    Variant_Base::template baseEmplace<t_INDEX>();
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::emplace()
{
    Variant_Base::template baseEmplace<t_INDEX>();
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::emplace()
{
    Variant_Base::template baseEmplace<t_INDEX>();
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::emplace()
{
    Variant_Base::template baseEmplace<t_INDEX>();
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::emplace()
{
    Variant_Base::template baseEmplace<t_INDEX>();
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::emplace()
{
    Variant_Base::template baseEmplace<t_INDEX>();
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16,
                                                      t_TAIL_17> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::emplace()
{
    Variant_Base::template baseEmplace<t_INDEX>();
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16,
                                                      t_TAIL_17,
                                                      t_TAIL_18> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::emplace()
{
    Variant_Base::template baseEmplace<t_INDEX>();
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <size_t t_INDEX, class t_ARG_01>
typename variant_alternative<t_INDEX, variant<t_HEAD> >::type&
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                >::emplace(const t_ARG_01& arg_01)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX, class t_ARG_01>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01> >::type&
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)
                >::emplace(const t_ARG_01& arg_01)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX, class t_ARG_01>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)
                >::emplace(const t_ARG_01& arg_01)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX, class t_ARG_01>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)
                >::emplace(const t_ARG_01& arg_01)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX, class t_ARG_01>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)
                >::emplace(const t_ARG_01& arg_01)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX, class t_ARG_01>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)
                >::emplace(const t_ARG_01& arg_01)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX, class t_ARG_01>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)
                >::emplace(const t_ARG_01& arg_01)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX, class t_ARG_01>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)
                >::emplace(const t_ARG_01& arg_01)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX, class t_ARG_01>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)
                >::emplace(const t_ARG_01& arg_01)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX, class t_ARG_01>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)
                >::emplace(const t_ARG_01& arg_01)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX, class t_ARG_01>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)
                >::emplace(const t_ARG_01& arg_01)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX, class t_ARG_01>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)
                >::emplace(const t_ARG_01& arg_01)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX, class t_ARG_01>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)
                >::emplace(const t_ARG_01& arg_01)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX, class t_ARG_01>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)
                >::emplace(const t_ARG_01& arg_01)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX, class t_ARG_01>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)
                >::emplace(const t_ARG_01& arg_01)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX, class t_ARG_01>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)
                >::emplace(const t_ARG_01& arg_01)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX, class t_ARG_01>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)
                >::emplace(const t_ARG_01& arg_01)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX, class t_ARG_01>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16,
                                                      t_TAIL_17> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)
                >::emplace(const t_ARG_01& arg_01)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX, class t_ARG_01>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16,
                                                      t_TAIL_17,
                                                      t_TAIL_18> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)
                >::emplace(const t_ARG_01& arg_01)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
typename variant_alternative<t_INDEX, variant<t_HEAD> >::type&
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01> >::type&
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16,
                                                      t_TAIL_17> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16,
                                                      t_TAIL_17,
                                                      t_TAIL_18> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename variant_alternative<t_INDEX, variant<t_HEAD> >::type&
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02, arg_03);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01> >::type&
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02, arg_03);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02, arg_03);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02, arg_03);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02, arg_03);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02, arg_03);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02, arg_03);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02, arg_03);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02, arg_03);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02, arg_03);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02, arg_03);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02, arg_03);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02, arg_03);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02, arg_03);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02, arg_03);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02, arg_03);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02, arg_03);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16,
                                                      t_TAIL_17> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02, arg_03);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16,
                                                      t_TAIL_17,
                                                      t_TAIL_18> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02, arg_03);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename variant_alternative<t_INDEX, variant<t_HEAD> >::type&
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01> >::type&
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16,
                                                      t_TAIL_17> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16,
                                                      t_TAIL_17,
                                                      t_TAIL_18> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename variant_alternative<t_INDEX, variant<t_HEAD> >::type&
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01> >::type&
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16,
                                                      t_TAIL_17> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16,
                                                      t_TAIL_17,
                                                      t_TAIL_18> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename variant_alternative<t_INDEX, variant<t_HEAD> >::type&
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01> >::type&
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16,
                                                      t_TAIL_17> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16,
                                                      t_TAIL_17,
                                                      t_TAIL_18> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename variant_alternative<t_INDEX, variant<t_HEAD> >::type&
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01> >::type&
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16,
                                                      t_TAIL_17> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16,
                                                      t_TAIL_17,
                                                      t_TAIL_18> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename variant_alternative<t_INDEX, variant<t_HEAD> >::type&
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01> >::type&
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16,
                                                      t_TAIL_17> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16,
                                                      t_TAIL_17,
                                                      t_TAIL_18> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename variant_alternative<t_INDEX, variant<t_HEAD> >::type&
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01> >::type&
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16,
                                                      t_TAIL_17> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16,
                                                      t_TAIL_17,
                                                      t_TAIL_18> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename variant_alternative<t_INDEX, variant<t_HEAD> >::type&
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09,
                                                arg_10);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01> >::type&
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09,
                                                arg_10);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09,
                                                arg_10);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09,
                                                arg_10);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09,
                                                arg_10);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09,
                                                arg_10);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09,
                                                arg_10);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09,
                                                arg_10);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09,
                                                arg_10);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09,
                                                arg_10);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09,
                                                arg_10);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09,
                                                arg_10);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09,
                                                arg_10);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09,
                                                arg_10);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09,
                                                arg_10);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09,
                                                arg_10);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09,
                                                arg_10);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16,
                                                      t_TAIL_17> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09,
                                                arg_10);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16,
                                                      t_TAIL_17,
                                                      t_TAIL_18> >::type&
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)
                >::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09,
                                                arg_10);
 
    return bsl::get<t_INDEX>(*this);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
inline
variant<t_HEAD>& variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::operator=(
                                                            const variant& rhs)
{
    Variant_Base::operator=(static_cast<const Variant_Base&>(rhs));
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
inline
variant<t_HEAD, t_TAIL_01>& variant<t_HEAD, t_TAIL_01,
                                            BSLS_COMPILERFEATURES_FILLT(17)
                                            >::operator=(
                                                            const variant& rhs)
{
    Variant_Base::operator=(static_cast<const Variant_Base&>(rhs));
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02>& variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            BSLS_COMPILERFEATURES_FILLT(16)
                                            >::operator=(
                                                            const variant& rhs)
{
    Variant_Base::operator=(static_cast<const Variant_Base&>(rhs));
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03>& variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            BSLS_COMPILERFEATURES_FILLT(15)
                                            >::operator=(
                                                            const variant& rhs)
{
    Variant_Base::operator=(static_cast<const Variant_Base&>(rhs));
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04>& variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            BSLS_COMPILERFEATURES_FILLT(14)
                                            >::operator=(
                                                            const variant& rhs)
{
    Variant_Base::operator=(static_cast<const Variant_Base&>(rhs));
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05>& variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            BSLS_COMPILERFEATURES_FILLT(13)
                                            >::operator=(
                                                            const variant& rhs)
{
    Variant_Base::operator=(static_cast<const Variant_Base&>(rhs));
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06>& variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            BSLS_COMPILERFEATURES_FILLT(12)
                                            >::operator=(
                                                            const variant& rhs)
{
    Variant_Base::operator=(static_cast<const Variant_Base&>(rhs));
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07>& variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            BSLS_COMPILERFEATURES_FILLT(11)
                                            >::operator=(
                                                            const variant& rhs)
{
    Variant_Base::operator=(static_cast<const Variant_Base&>(rhs));
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08>& variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            BSLS_COMPILERFEATURES_FILLT(10)
                                            >::operator=(
                                                            const variant& rhs)
{
    Variant_Base::operator=(static_cast<const Variant_Base&>(rhs));
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09>& variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            BSLS_COMPILERFEATURES_FILLT( 9)
                                            >::operator=(
                                                            const variant& rhs)
{
    Variant_Base::operator=(static_cast<const Variant_Base&>(rhs));
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10>& variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            BSLS_COMPILERFEATURES_FILLT( 8)
                                            >::operator=(
                                                            const variant& rhs)
{
    Variant_Base::operator=(static_cast<const Variant_Base&>(rhs));
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11>& variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            BSLS_COMPILERFEATURES_FILLT( 7)
                                            >::operator=(
                                                            const variant& rhs)
{
    Variant_Base::operator=(static_cast<const Variant_Base&>(rhs));
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12>& variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            BSLS_COMPILERFEATURES_FILLT( 6)
                                            >::operator=(
                                                            const variant& rhs)
{
    Variant_Base::operator=(static_cast<const Variant_Base&>(rhs));
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13>& variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            BSLS_COMPILERFEATURES_FILLT( 5)
                                            >::operator=(
                                                            const variant& rhs)
{
    Variant_Base::operator=(static_cast<const Variant_Base&>(rhs));
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14>& variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            BSLS_COMPILERFEATURES_FILLT( 4)
                                            >::operator=(
                                                            const variant& rhs)
{
    Variant_Base::operator=(static_cast<const Variant_Base&>(rhs));
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15>& variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            BSLS_COMPILERFEATURES_FILLT( 3)
                                            >::operator=(
                                                            const variant& rhs)
{
    Variant_Base::operator=(static_cast<const Variant_Base&>(rhs));
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16>& variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16,
                                            BSLS_COMPILERFEATURES_FILLT( 2)
                                            >::operator=(
                                                            const variant& rhs)
{
    Variant_Base::operator=(static_cast<const Variant_Base&>(rhs));
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17>& variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16,
                                            t_TAIL_17,
                                            BSLS_COMPILERFEATURES_FILLT( 1)
                                            >::operator=(
                                                            const variant& rhs)
{
    Variant_Base::operator=(static_cast<const Variant_Base&>(rhs));
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18>& variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16,
                                            t_TAIL_17,
                                            t_TAIL_18,
                                            BSLS_COMPILERFEATURES_FILLT( 0)
                                            >::operator=(
                                                            const variant& rhs)
{
    Variant_Base::operator=(static_cast<const Variant_Base&>(rhs));
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
inline
variant<t_HEAD>& variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::operator=(
                                   BloombergLP::bslmf::MovableRef<variant> rhs)
{
    variant<t_HEAD>& lvalue = rhs;
    Variant_Base::operator=(
                           MoveUtil::move(static_cast<Variant_Base&>(lvalue)));
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
inline
variant<t_HEAD, t_TAIL_01>& variant<t_HEAD, t_TAIL_01,
                                            BSLS_COMPILERFEATURES_FILLT(17)
                                            >::operator=(
                                   BloombergLP::bslmf::MovableRef<variant> rhs)
{
    variant<t_HEAD, t_TAIL_01>& lvalue = rhs;
    Variant_Base::operator=(
                           MoveUtil::move(static_cast<Variant_Base&>(lvalue)));
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02>& variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            BSLS_COMPILERFEATURES_FILLT(16)
                                            >::operator=(
                                   BloombergLP::bslmf::MovableRef<variant> rhs)
{
    variant<t_HEAD, t_TAIL_01,
                    t_TAIL_02>& lvalue = rhs;
    Variant_Base::operator=(
                           MoveUtil::move(static_cast<Variant_Base&>(lvalue)));
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03>& variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            BSLS_COMPILERFEATURES_FILLT(15)
                                            >::operator=(
                                   BloombergLP::bslmf::MovableRef<variant> rhs)
{
    variant<t_HEAD, t_TAIL_01,
                    t_TAIL_02,
                    t_TAIL_03>& lvalue = rhs;
    Variant_Base::operator=(
                           MoveUtil::move(static_cast<Variant_Base&>(lvalue)));
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04>& variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            BSLS_COMPILERFEATURES_FILLT(14)
                                            >::operator=(
                                   BloombergLP::bslmf::MovableRef<variant> rhs)
{
    variant<t_HEAD, t_TAIL_01,
                    t_TAIL_02,
                    t_TAIL_03,
                    t_TAIL_04>& lvalue = rhs;
    Variant_Base::operator=(
                           MoveUtil::move(static_cast<Variant_Base&>(lvalue)));
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05>& variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            BSLS_COMPILERFEATURES_FILLT(13)
                                            >::operator=(
                                   BloombergLP::bslmf::MovableRef<variant> rhs)
{
    variant<t_HEAD, t_TAIL_01,
                    t_TAIL_02,
                    t_TAIL_03,
                    t_TAIL_04,
                    t_TAIL_05>& lvalue = rhs;
    Variant_Base::operator=(
                           MoveUtil::move(static_cast<Variant_Base&>(lvalue)));
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06>& variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            BSLS_COMPILERFEATURES_FILLT(12)
                                            >::operator=(
                                   BloombergLP::bslmf::MovableRef<variant> rhs)
{
    variant<t_HEAD, t_TAIL_01,
                    t_TAIL_02,
                    t_TAIL_03,
                    t_TAIL_04,
                    t_TAIL_05,
                    t_TAIL_06>& lvalue = rhs;
    Variant_Base::operator=(
                           MoveUtil::move(static_cast<Variant_Base&>(lvalue)));
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07>& variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            BSLS_COMPILERFEATURES_FILLT(11)
                                            >::operator=(
                                   BloombergLP::bslmf::MovableRef<variant> rhs)
{
    variant<t_HEAD, t_TAIL_01,
                    t_TAIL_02,
                    t_TAIL_03,
                    t_TAIL_04,
                    t_TAIL_05,
                    t_TAIL_06,
                    t_TAIL_07>& lvalue = rhs;
    Variant_Base::operator=(
                           MoveUtil::move(static_cast<Variant_Base&>(lvalue)));
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08>& variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            BSLS_COMPILERFEATURES_FILLT(10)
                                            >::operator=(
                                   BloombergLP::bslmf::MovableRef<variant> rhs)
{
    variant<t_HEAD, t_TAIL_01,
                    t_TAIL_02,
                    t_TAIL_03,
                    t_TAIL_04,
                    t_TAIL_05,
                    t_TAIL_06,
                    t_TAIL_07,
                    t_TAIL_08>& lvalue = rhs;
    Variant_Base::operator=(
                           MoveUtil::move(static_cast<Variant_Base&>(lvalue)));
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09>& variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            BSLS_COMPILERFEATURES_FILLT( 9)
                                            >::operator=(
                                   BloombergLP::bslmf::MovableRef<variant> rhs)
{
    variant<t_HEAD, t_TAIL_01,
                    t_TAIL_02,
                    t_TAIL_03,
                    t_TAIL_04,
                    t_TAIL_05,
                    t_TAIL_06,
                    t_TAIL_07,
                    t_TAIL_08,
                    t_TAIL_09>& lvalue = rhs;
    Variant_Base::operator=(
                           MoveUtil::move(static_cast<Variant_Base&>(lvalue)));
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10>& variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            BSLS_COMPILERFEATURES_FILLT( 8)
                                            >::operator=(
                                   BloombergLP::bslmf::MovableRef<variant> rhs)
{
    variant<t_HEAD, t_TAIL_01,
                    t_TAIL_02,
                    t_TAIL_03,
                    t_TAIL_04,
                    t_TAIL_05,
                    t_TAIL_06,
                    t_TAIL_07,
                    t_TAIL_08,
                    t_TAIL_09,
                    t_TAIL_10>& lvalue = rhs;
    Variant_Base::operator=(
                           MoveUtil::move(static_cast<Variant_Base&>(lvalue)));
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11>& variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            BSLS_COMPILERFEATURES_FILLT( 7)
                                            >::operator=(
                                   BloombergLP::bslmf::MovableRef<variant> rhs)
{
    variant<t_HEAD, t_TAIL_01,
                    t_TAIL_02,
                    t_TAIL_03,
                    t_TAIL_04,
                    t_TAIL_05,
                    t_TAIL_06,
                    t_TAIL_07,
                    t_TAIL_08,
                    t_TAIL_09,
                    t_TAIL_10,
                    t_TAIL_11>& lvalue = rhs;
    Variant_Base::operator=(
                           MoveUtil::move(static_cast<Variant_Base&>(lvalue)));
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12>& variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            BSLS_COMPILERFEATURES_FILLT( 6)
                                            >::operator=(
                                   BloombergLP::bslmf::MovableRef<variant> rhs)
{
    variant<t_HEAD, t_TAIL_01,
                    t_TAIL_02,
                    t_TAIL_03,
                    t_TAIL_04,
                    t_TAIL_05,
                    t_TAIL_06,
                    t_TAIL_07,
                    t_TAIL_08,
                    t_TAIL_09,
                    t_TAIL_10,
                    t_TAIL_11,
                    t_TAIL_12>& lvalue = rhs;
    Variant_Base::operator=(
                           MoveUtil::move(static_cast<Variant_Base&>(lvalue)));
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13>& variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            BSLS_COMPILERFEATURES_FILLT( 5)
                                            >::operator=(
                                   BloombergLP::bslmf::MovableRef<variant> rhs)
{
    variant<t_HEAD, t_TAIL_01,
                    t_TAIL_02,
                    t_TAIL_03,
                    t_TAIL_04,
                    t_TAIL_05,
                    t_TAIL_06,
                    t_TAIL_07,
                    t_TAIL_08,
                    t_TAIL_09,
                    t_TAIL_10,
                    t_TAIL_11,
                    t_TAIL_12,
                    t_TAIL_13>& lvalue = rhs;
    Variant_Base::operator=(
                           MoveUtil::move(static_cast<Variant_Base&>(lvalue)));
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14>& variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            BSLS_COMPILERFEATURES_FILLT( 4)
                                            >::operator=(
                                   BloombergLP::bslmf::MovableRef<variant> rhs)
{
    variant<t_HEAD, t_TAIL_01,
                    t_TAIL_02,
                    t_TAIL_03,
                    t_TAIL_04,
                    t_TAIL_05,
                    t_TAIL_06,
                    t_TAIL_07,
                    t_TAIL_08,
                    t_TAIL_09,
                    t_TAIL_10,
                    t_TAIL_11,
                    t_TAIL_12,
                    t_TAIL_13,
                    t_TAIL_14>& lvalue = rhs;
    Variant_Base::operator=(
                           MoveUtil::move(static_cast<Variant_Base&>(lvalue)));
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15>& variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            BSLS_COMPILERFEATURES_FILLT( 3)
                                            >::operator=(
                                   BloombergLP::bslmf::MovableRef<variant> rhs)
{
    variant<t_HEAD, t_TAIL_01,
                    t_TAIL_02,
                    t_TAIL_03,
                    t_TAIL_04,
                    t_TAIL_05,
                    t_TAIL_06,
                    t_TAIL_07,
                    t_TAIL_08,
                    t_TAIL_09,
                    t_TAIL_10,
                    t_TAIL_11,
                    t_TAIL_12,
                    t_TAIL_13,
                    t_TAIL_14,
                    t_TAIL_15>& lvalue = rhs;
    Variant_Base::operator=(
                           MoveUtil::move(static_cast<Variant_Base&>(lvalue)));
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16>& variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16,
                                            BSLS_COMPILERFEATURES_FILLT( 2)
                                            >::operator=(
                                   BloombergLP::bslmf::MovableRef<variant> rhs)
{
    variant<t_HEAD, t_TAIL_01,
                    t_TAIL_02,
                    t_TAIL_03,
                    t_TAIL_04,
                    t_TAIL_05,
                    t_TAIL_06,
                    t_TAIL_07,
                    t_TAIL_08,
                    t_TAIL_09,
                    t_TAIL_10,
                    t_TAIL_11,
                    t_TAIL_12,
                    t_TAIL_13,
                    t_TAIL_14,
                    t_TAIL_15,
                    t_TAIL_16>& lvalue = rhs;
    Variant_Base::operator=(
                           MoveUtil::move(static_cast<Variant_Base&>(lvalue)));
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17>& variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16,
                                            t_TAIL_17,
                                            BSLS_COMPILERFEATURES_FILLT( 1)
                                            >::operator=(
                                   BloombergLP::bslmf::MovableRef<variant> rhs)
{
    variant<t_HEAD, t_TAIL_01,
                    t_TAIL_02,
                    t_TAIL_03,
                    t_TAIL_04,
                    t_TAIL_05,
                    t_TAIL_06,
                    t_TAIL_07,
                    t_TAIL_08,
                    t_TAIL_09,
                    t_TAIL_10,
                    t_TAIL_11,
                    t_TAIL_12,
                    t_TAIL_13,
                    t_TAIL_14,
                    t_TAIL_15,
                    t_TAIL_16,
                    t_TAIL_17>& lvalue = rhs;
    Variant_Base::operator=(
                           MoveUtil::move(static_cast<Variant_Base&>(lvalue)));
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
inline
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18>& variant<t_HEAD, t_TAIL_01,
                                            t_TAIL_02,
                                            t_TAIL_03,
                                            t_TAIL_04,
                                            t_TAIL_05,
                                            t_TAIL_06,
                                            t_TAIL_07,
                                            t_TAIL_08,
                                            t_TAIL_09,
                                            t_TAIL_10,
                                            t_TAIL_11,
                                            t_TAIL_12,
                                            t_TAIL_13,
                                            t_TAIL_14,
                                            t_TAIL_15,
                                            t_TAIL_16,
                                            t_TAIL_17,
                                            t_TAIL_18,
                                            BSLS_COMPILERFEATURES_FILLT( 0)
                                            >::operator=(
                                   BloombergLP::bslmf::MovableRef<variant> rhs)
{
    variant<t_HEAD, t_TAIL_01,
                    t_TAIL_02,
                    t_TAIL_03,
                    t_TAIL_04,
                    t_TAIL_05,
                    t_TAIL_06,
                    t_TAIL_07,
                    t_TAIL_08,
                    t_TAIL_09,
                    t_TAIL_10,
                    t_TAIL_11,
                    t_TAIL_12,
                    t_TAIL_13,
                    t_TAIL_14,
                    t_TAIL_15,
                    t_TAIL_16,
                    t_TAIL_17,
                    t_TAIL_18>& lvalue = rhs;
    Variant_Base::operator=(
                           MoveUtil::move(static_cast<Variant_Base&>(lvalue)));
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
template <class t_HEAD>
template <class t_TYPE>
inline
typename bsl::enable_if<
    BloombergLP::bslstl::Variant_AssignsFromType<variant<t_HEAD>,
                                                 t_TYPE>::value,
    variant<t_HEAD>&>::type
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::operator=(const t_TYPE& rhs)
{
    const size_t altIndex = BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
    if (index() == altIndex) {
        bsl::get<altIndex>(*this) = rhs;
    }
    else {
        emplace<altIndex>(rhs);
    }
 
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
template <class t_HEAD, class t_TAIL_01>
template <class t_TYPE>
inline
typename bsl::enable_if<
    BloombergLP::bslstl::Variant_AssignsFromType<variant<t_HEAD, t_TAIL_01>,
                                                 t_TYPE>::value,
    variant<t_HEAD, t_TAIL_01>&>::type
variant<t_HEAD, t_TAIL_01,
                BSLS_COMPILERFEATURES_FILLT(17)>::operator=(const t_TYPE& rhs)
{
    const size_t altIndex = BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
    if (index() == altIndex) {
        bsl::get<altIndex>(*this) = rhs;
    }
    else {
        emplace<altIndex>(rhs);
    }
 
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
template <class t_TYPE>
inline
typename bsl::enable_if<
    BloombergLP::bslstl::Variant_AssignsFromType<variant<t_HEAD, t_TAIL_01,
                                                                 t_TAIL_02>,
                                                 t_TYPE>::value,
    variant<t_HEAD, t_TAIL_01,
                    t_TAIL_02>&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                BSLS_COMPILERFEATURES_FILLT(16)>::operator=(const t_TYPE& rhs)
{
    const size_t altIndex = BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
    if (index() == altIndex) {
        bsl::get<altIndex>(*this) = rhs;
    }
    else {
        emplace<altIndex>(rhs);
    }
 
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
template <class t_TYPE>
inline
typename bsl::enable_if<
    BloombergLP::bslstl::Variant_AssignsFromType<variant<t_HEAD, t_TAIL_01,
                                                                 t_TAIL_02,
                                                                 t_TAIL_03>,
                                                 t_TYPE>::value,
    variant<t_HEAD, t_TAIL_01,
                    t_TAIL_02,
                    t_TAIL_03>&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::operator=(const t_TYPE& rhs)
{
    const size_t altIndex = BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
    if (index() == altIndex) {
        bsl::get<altIndex>(*this) = rhs;
    }
    else {
        emplace<altIndex>(rhs);
    }
 
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
template <class t_TYPE>
inline
typename bsl::enable_if<
    BloombergLP::bslstl::Variant_AssignsFromType<variant<t_HEAD, t_TAIL_01,
                                                                 t_TAIL_02,
                                                                 t_TAIL_03,
                                                                 t_TAIL_04>,
                                                 t_TYPE>::value,
    variant<t_HEAD, t_TAIL_01,
                    t_TAIL_02,
                    t_TAIL_03,
                    t_TAIL_04>&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                BSLS_COMPILERFEATURES_FILLT(14)>::operator=(const t_TYPE& rhs)
{
    const size_t altIndex = BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
    if (index() == altIndex) {
        bsl::get<altIndex>(*this) = rhs;
    }
    else {
        emplace<altIndex>(rhs);
    }
 
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
template <class t_TYPE>
inline
typename bsl::enable_if<
    BloombergLP::bslstl::Variant_AssignsFromType<variant<t_HEAD, t_TAIL_01,
                                                                 t_TAIL_02,
                                                                 t_TAIL_03,
                                                                 t_TAIL_04,
                                                                 t_TAIL_05>,
                                                 t_TYPE>::value,
    variant<t_HEAD, t_TAIL_01,
                    t_TAIL_02,
                    t_TAIL_03,
                    t_TAIL_04,
                    t_TAIL_05>&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                BSLS_COMPILERFEATURES_FILLT(13)>::operator=(const t_TYPE& rhs)
{
    const size_t altIndex = BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
    if (index() == altIndex) {
        bsl::get<altIndex>(*this) = rhs;
    }
    else {
        emplace<altIndex>(rhs);
    }
 
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
template <class t_TYPE>
inline
typename bsl::enable_if<
    BloombergLP::bslstl::Variant_AssignsFromType<variant<t_HEAD, t_TAIL_01,
                                                                 t_TAIL_02,
                                                                 t_TAIL_03,
                                                                 t_TAIL_04,
                                                                 t_TAIL_05,
                                                                 t_TAIL_06>,
                                                 t_TYPE>::value,
    variant<t_HEAD, t_TAIL_01,
                    t_TAIL_02,
                    t_TAIL_03,
                    t_TAIL_04,
                    t_TAIL_05,
                    t_TAIL_06>&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                BSLS_COMPILERFEATURES_FILLT(12)>::operator=(const t_TYPE& rhs)
{
    const size_t altIndex = BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
    if (index() == altIndex) {
        bsl::get<altIndex>(*this) = rhs;
    }
    else {
        emplace<altIndex>(rhs);
    }
 
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
template <class t_TYPE>
inline
typename bsl::enable_if<
    BloombergLP::bslstl::Variant_AssignsFromType<variant<t_HEAD, t_TAIL_01,
                                                                 t_TAIL_02,
                                                                 t_TAIL_03,
                                                                 t_TAIL_04,
                                                                 t_TAIL_05,
                                                                 t_TAIL_06,
                                                                 t_TAIL_07>,
                                                 t_TYPE>::value,
    variant<t_HEAD, t_TAIL_01,
                    t_TAIL_02,
                    t_TAIL_03,
                    t_TAIL_04,
                    t_TAIL_05,
                    t_TAIL_06,
                    t_TAIL_07>&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                BSLS_COMPILERFEATURES_FILLT(11)>::operator=(const t_TYPE& rhs)
{
    const size_t altIndex = BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
    if (index() == altIndex) {
        bsl::get<altIndex>(*this) = rhs;
    }
    else {
        emplace<altIndex>(rhs);
    }
 
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
template <class t_TYPE>
inline
typename bsl::enable_if<
    BloombergLP::bslstl::Variant_AssignsFromType<variant<t_HEAD, t_TAIL_01,
                                                                 t_TAIL_02,
                                                                 t_TAIL_03,
                                                                 t_TAIL_04,
                                                                 t_TAIL_05,
                                                                 t_TAIL_06,
                                                                 t_TAIL_07,
                                                                 t_TAIL_08>,
                                                 t_TYPE>::value,
    variant<t_HEAD, t_TAIL_01,
                    t_TAIL_02,
                    t_TAIL_03,
                    t_TAIL_04,
                    t_TAIL_05,
                    t_TAIL_06,
                    t_TAIL_07,
                    t_TAIL_08>&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                BSLS_COMPILERFEATURES_FILLT(10)>::operator=(const t_TYPE& rhs)
{
    const size_t altIndex = BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
    if (index() == altIndex) {
        bsl::get<altIndex>(*this) = rhs;
    }
    else {
        emplace<altIndex>(rhs);
    }
 
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
template <class t_TYPE>
inline
typename bsl::enable_if<
    BloombergLP::bslstl::Variant_AssignsFromType<variant<t_HEAD, t_TAIL_01,
                                                                 t_TAIL_02,
                                                                 t_TAIL_03,
                                                                 t_TAIL_04,
                                                                 t_TAIL_05,
                                                                 t_TAIL_06,
                                                                 t_TAIL_07,
                                                                 t_TAIL_08,
                                                                 t_TAIL_09>,
                                                 t_TYPE>::value,
    variant<t_HEAD, t_TAIL_01,
                    t_TAIL_02,
                    t_TAIL_03,
                    t_TAIL_04,
                    t_TAIL_05,
                    t_TAIL_06,
                    t_TAIL_07,
                    t_TAIL_08,
                    t_TAIL_09>&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                BSLS_COMPILERFEATURES_FILLT( 9)>::operator=(const t_TYPE& rhs)
{
    const size_t altIndex = BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
    if (index() == altIndex) {
        bsl::get<altIndex>(*this) = rhs;
    }
    else {
        emplace<altIndex>(rhs);
    }
 
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
template <class t_TYPE>
inline
typename bsl::enable_if<
    BloombergLP::bslstl::Variant_AssignsFromType<variant<t_HEAD, t_TAIL_01,
                                                                 t_TAIL_02,
                                                                 t_TAIL_03,
                                                                 t_TAIL_04,
                                                                 t_TAIL_05,
                                                                 t_TAIL_06,
                                                                 t_TAIL_07,
                                                                 t_TAIL_08,
                                                                 t_TAIL_09,
                                                                 t_TAIL_10>,
                                                 t_TYPE>::value,
    variant<t_HEAD, t_TAIL_01,
                    t_TAIL_02,
                    t_TAIL_03,
                    t_TAIL_04,
                    t_TAIL_05,
                    t_TAIL_06,
                    t_TAIL_07,
                    t_TAIL_08,
                    t_TAIL_09,
                    t_TAIL_10>&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                BSLS_COMPILERFEATURES_FILLT( 8)>::operator=(const t_TYPE& rhs)
{
    const size_t altIndex = BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
    if (index() == altIndex) {
        bsl::get<altIndex>(*this) = rhs;
    }
    else {
        emplace<altIndex>(rhs);
    }
 
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
template <class t_TYPE>
inline
typename bsl::enable_if<
    BloombergLP::bslstl::Variant_AssignsFromType<variant<t_HEAD, t_TAIL_01,
                                                                 t_TAIL_02,
                                                                 t_TAIL_03,
                                                                 t_TAIL_04,
                                                                 t_TAIL_05,
                                                                 t_TAIL_06,
                                                                 t_TAIL_07,
                                                                 t_TAIL_08,
                                                                 t_TAIL_09,
                                                                 t_TAIL_10,
                                                                 t_TAIL_11>,
                                                 t_TYPE>::value,
    variant<t_HEAD, t_TAIL_01,
                    t_TAIL_02,
                    t_TAIL_03,
                    t_TAIL_04,
                    t_TAIL_05,
                    t_TAIL_06,
                    t_TAIL_07,
                    t_TAIL_08,
                    t_TAIL_09,
                    t_TAIL_10,
                    t_TAIL_11>&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                BSLS_COMPILERFEATURES_FILLT( 7)>::operator=(const t_TYPE& rhs)
{
    const size_t altIndex = BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
    if (index() == altIndex) {
        bsl::get<altIndex>(*this) = rhs;
    }
    else {
        emplace<altIndex>(rhs);
    }
 
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
template <class t_TYPE>
inline
typename bsl::enable_if<
    BloombergLP::bslstl::Variant_AssignsFromType<variant<t_HEAD, t_TAIL_01,
                                                                 t_TAIL_02,
                                                                 t_TAIL_03,
                                                                 t_TAIL_04,
                                                                 t_TAIL_05,
                                                                 t_TAIL_06,
                                                                 t_TAIL_07,
                                                                 t_TAIL_08,
                                                                 t_TAIL_09,
                                                                 t_TAIL_10,
                                                                 t_TAIL_11,
                                                                 t_TAIL_12>,
                                                 t_TYPE>::value,
    variant<t_HEAD, t_TAIL_01,
                    t_TAIL_02,
                    t_TAIL_03,
                    t_TAIL_04,
                    t_TAIL_05,
                    t_TAIL_06,
                    t_TAIL_07,
                    t_TAIL_08,
                    t_TAIL_09,
                    t_TAIL_10,
                    t_TAIL_11,
                    t_TAIL_12>&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                BSLS_COMPILERFEATURES_FILLT( 6)>::operator=(const t_TYPE& rhs)
{
    const size_t altIndex = BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
    if (index() == altIndex) {
        bsl::get<altIndex>(*this) = rhs;
    }
    else {
        emplace<altIndex>(rhs);
    }
 
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
template <class t_TYPE>
inline
typename bsl::enable_if<
    BloombergLP::bslstl::Variant_AssignsFromType<variant<t_HEAD, t_TAIL_01,
                                                                 t_TAIL_02,
                                                                 t_TAIL_03,
                                                                 t_TAIL_04,
                                                                 t_TAIL_05,
                                                                 t_TAIL_06,
                                                                 t_TAIL_07,
                                                                 t_TAIL_08,
                                                                 t_TAIL_09,
                                                                 t_TAIL_10,
                                                                 t_TAIL_11,
                                                                 t_TAIL_12,
                                                                 t_TAIL_13>,
                                                 t_TYPE>::value,
    variant<t_HEAD, t_TAIL_01,
                    t_TAIL_02,
                    t_TAIL_03,
                    t_TAIL_04,
                    t_TAIL_05,
                    t_TAIL_06,
                    t_TAIL_07,
                    t_TAIL_08,
                    t_TAIL_09,
                    t_TAIL_10,
                    t_TAIL_11,
                    t_TAIL_12,
                    t_TAIL_13>&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                BSLS_COMPILERFEATURES_FILLT( 5)>::operator=(const t_TYPE& rhs)
{
    const size_t altIndex = BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
    if (index() == altIndex) {
        bsl::get<altIndex>(*this) = rhs;
    }
    else {
        emplace<altIndex>(rhs);
    }
 
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
template <class t_TYPE>
inline
typename bsl::enable_if<
    BloombergLP::bslstl::Variant_AssignsFromType<variant<t_HEAD, t_TAIL_01,
                                                                 t_TAIL_02,
                                                                 t_TAIL_03,
                                                                 t_TAIL_04,
                                                                 t_TAIL_05,
                                                                 t_TAIL_06,
                                                                 t_TAIL_07,
                                                                 t_TAIL_08,
                                                                 t_TAIL_09,
                                                                 t_TAIL_10,
                                                                 t_TAIL_11,
                                                                 t_TAIL_12,
                                                                 t_TAIL_13,
                                                                 t_TAIL_14>,
                                                 t_TYPE>::value,
    variant<t_HEAD, t_TAIL_01,
                    t_TAIL_02,
                    t_TAIL_03,
                    t_TAIL_04,
                    t_TAIL_05,
                    t_TAIL_06,
                    t_TAIL_07,
                    t_TAIL_08,
                    t_TAIL_09,
                    t_TAIL_10,
                    t_TAIL_11,
                    t_TAIL_12,
                    t_TAIL_13,
                    t_TAIL_14>&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                BSLS_COMPILERFEATURES_FILLT( 4)>::operator=(const t_TYPE& rhs)
{
    const size_t altIndex = BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
    if (index() == altIndex) {
        bsl::get<altIndex>(*this) = rhs;
    }
    else {
        emplace<altIndex>(rhs);
    }
 
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
template <class t_TYPE>
inline
typename bsl::enable_if<
    BloombergLP::bslstl::Variant_AssignsFromType<variant<t_HEAD, t_TAIL_01,
                                                                 t_TAIL_02,
                                                                 t_TAIL_03,
                                                                 t_TAIL_04,
                                                                 t_TAIL_05,
                                                                 t_TAIL_06,
                                                                 t_TAIL_07,
                                                                 t_TAIL_08,
                                                                 t_TAIL_09,
                                                                 t_TAIL_10,
                                                                 t_TAIL_11,
                                                                 t_TAIL_12,
                                                                 t_TAIL_13,
                                                                 t_TAIL_14,
                                                                 t_TAIL_15>,
                                                 t_TYPE>::value,
    variant<t_HEAD, t_TAIL_01,
                    t_TAIL_02,
                    t_TAIL_03,
                    t_TAIL_04,
                    t_TAIL_05,
                    t_TAIL_06,
                    t_TAIL_07,
                    t_TAIL_08,
                    t_TAIL_09,
                    t_TAIL_10,
                    t_TAIL_11,
                    t_TAIL_12,
                    t_TAIL_13,
                    t_TAIL_14,
                    t_TAIL_15>&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                BSLS_COMPILERFEATURES_FILLT( 3)>::operator=(const t_TYPE& rhs)
{
    const size_t altIndex = BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
    if (index() == altIndex) {
        bsl::get<altIndex>(*this) = rhs;
    }
    else {
        emplace<altIndex>(rhs);
    }
 
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
template <class t_TYPE>
inline
typename bsl::enable_if<
    BloombergLP::bslstl::Variant_AssignsFromType<variant<t_HEAD, t_TAIL_01,
                                                                 t_TAIL_02,
                                                                 t_TAIL_03,
                                                                 t_TAIL_04,
                                                                 t_TAIL_05,
                                                                 t_TAIL_06,
                                                                 t_TAIL_07,
                                                                 t_TAIL_08,
                                                                 t_TAIL_09,
                                                                 t_TAIL_10,
                                                                 t_TAIL_11,
                                                                 t_TAIL_12,
                                                                 t_TAIL_13,
                                                                 t_TAIL_14,
                                                                 t_TAIL_15,
                                                                 t_TAIL_16>,
                                                 t_TYPE>::value,
    variant<t_HEAD, t_TAIL_01,
                    t_TAIL_02,
                    t_TAIL_03,
                    t_TAIL_04,
                    t_TAIL_05,
                    t_TAIL_06,
                    t_TAIL_07,
                    t_TAIL_08,
                    t_TAIL_09,
                    t_TAIL_10,
                    t_TAIL_11,
                    t_TAIL_12,
                    t_TAIL_13,
                    t_TAIL_14,
                    t_TAIL_15,
                    t_TAIL_16>&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                BSLS_COMPILERFEATURES_FILLT( 2)>::operator=(const t_TYPE& rhs)
{
    const size_t altIndex = BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
    if (index() == altIndex) {
        bsl::get<altIndex>(*this) = rhs;
    }
    else {
        emplace<altIndex>(rhs);
    }
 
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
template <class t_TYPE>
inline
typename bsl::enable_if<
    BloombergLP::bslstl::Variant_AssignsFromType<variant<t_HEAD, t_TAIL_01,
                                                                 t_TAIL_02,
                                                                 t_TAIL_03,
                                                                 t_TAIL_04,
                                                                 t_TAIL_05,
                                                                 t_TAIL_06,
                                                                 t_TAIL_07,
                                                                 t_TAIL_08,
                                                                 t_TAIL_09,
                                                                 t_TAIL_10,
                                                                 t_TAIL_11,
                                                                 t_TAIL_12,
                                                                 t_TAIL_13,
                                                                 t_TAIL_14,
                                                                 t_TAIL_15,
                                                                 t_TAIL_16,
                                                                 t_TAIL_17>,
                                                 t_TYPE>::value,
    variant<t_HEAD, t_TAIL_01,
                    t_TAIL_02,
                    t_TAIL_03,
                    t_TAIL_04,
                    t_TAIL_05,
                    t_TAIL_06,
                    t_TAIL_07,
                    t_TAIL_08,
                    t_TAIL_09,
                    t_TAIL_10,
                    t_TAIL_11,
                    t_TAIL_12,
                    t_TAIL_13,
                    t_TAIL_14,
                    t_TAIL_15,
                    t_TAIL_16,
                    t_TAIL_17>&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                BSLS_COMPILERFEATURES_FILLT( 1)>::operator=(const t_TYPE& rhs)
{
    const size_t altIndex = BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
    if (index() == altIndex) {
        bsl::get<altIndex>(*this) = rhs;
    }
    else {
        emplace<altIndex>(rhs);
    }
 
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
template <class t_TYPE>
inline
typename bsl::enable_if<
    BloombergLP::bslstl::Variant_AssignsFromType<variant<t_HEAD, t_TAIL_01,
                                                                 t_TAIL_02,
                                                                 t_TAIL_03,
                                                                 t_TAIL_04,
                                                                 t_TAIL_05,
                                                                 t_TAIL_06,
                                                                 t_TAIL_07,
                                                                 t_TAIL_08,
                                                                 t_TAIL_09,
                                                                 t_TAIL_10,
                                                                 t_TAIL_11,
                                                                 t_TAIL_12,
                                                                 t_TAIL_13,
                                                                 t_TAIL_14,
                                                                 t_TAIL_15,
                                                                 t_TAIL_16,
                                                                 t_TAIL_17,
                                                                 t_TAIL_18>,
                                                 t_TYPE>::value,
    variant<t_HEAD, t_TAIL_01,
                    t_TAIL_02,
                    t_TAIL_03,
                    t_TAIL_04,
                    t_TAIL_05,
                    t_TAIL_06,
                    t_TAIL_07,
                    t_TAIL_08,
                    t_TAIL_09,
                    t_TAIL_10,
                    t_TAIL_11,
                    t_TAIL_12,
                    t_TAIL_13,
                    t_TAIL_14,
                    t_TAIL_15,
                    t_TAIL_16,
                    t_TAIL_17,
                    t_TAIL_18>&>::type
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                t_TAIL_11,
                t_TAIL_12,
                t_TAIL_13,
                t_TAIL_14,
                t_TAIL_15,
                t_TAIL_16,
                t_TAIL_17,
                t_TAIL_18,
                BSLS_COMPILERFEATURES_FILLT( 0)>::operator=(const t_TYPE& rhs)
{
    const size_t altIndex = BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
    if (index() == altIndex) {
        bsl::get<altIndex>(*this) = rhs;
    }
    else {
        emplace<altIndex>(rhs);
    }
 
    return *this;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 18
 
#else
// The generated code below is a workaround for the absence of perfect
// forwarding in some compilers.
template <class t_HEAD, class... t_TAIL>
inline
variant<t_HEAD, t_TAIL...>::variant()
: Variant_Base()
{
}
 
template <class t_HEAD, class... t_TAIL>
inline
variant<t_HEAD, t_TAIL...>::variant(const variant& original)
: Variant_Base(original)
{
}
 
template <class t_HEAD, class... t_TAIL>
inline
variant<t_HEAD, t_TAIL...>::variant(
                              BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(original)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL...>::variant(
    const t_TYPE& value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL...>::variant(
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
 
template <class t_HEAD, class... t_TAIL>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL...>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL...>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL...>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL...>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL...>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL...>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL...>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL...>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL...>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL...>::variant(
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX>
inline
variant<t_HEAD, t_TAIL...>::variant(bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::in_place_index_t<t_INDEX>())
{
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL...>::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL...>::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL...>::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01&                arg_01,
                                    const t_ARG_02&                arg_02,
                                    const t_ARG_03&                arg_03)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(), arg_01, arg_02, arg_03)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL...>::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL...>::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL...>::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL...>::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL...>::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL...>::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL...>::variant(bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
 
template <class t_HEAD, class... t_TAIL>
inline
variant<t_HEAD, t_TAIL...>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator)
: Variant_Base(bsl::allocator_arg_t(), allocator)
{
}
 
template <class t_HEAD, class... t_TAIL>
inline
variant<t_HEAD, t_TAIL...>::variant(bsl::allocator_arg_t,
                                    allocator_type       allocator,
                                    const variant&       original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
 
template <class t_HEAD, class... t_TAIL>
inline
variant<t_HEAD, t_TAIL...>::variant(
                             bsl::allocator_arg_t,
                             allocator_type                          allocator,
                             BloombergLP::bslmf::MovableRef<variant> original)
: Variant_Base(bsl::allocator_arg_t(), allocator, original)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL...>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    const t_TYPE&  value,
    BSLSTL_VARIANT_DEFINE_IF_CONSTRUCTS_FROM(variant, t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE,
                                                            variant)>(),
      value)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <class t_TYPE>
inline
variant<t_HEAD, t_TAIL...>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>())
{
}
 
template <class t_HEAD, class... t_TAIL>
template <class t_TYPE, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL...>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL...>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL...>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL...>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL...>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL...>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL...>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL...>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL...>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL...>::variant(
    bsl::allocator_arg_t,
    allocator_type allocator,
    bsl::in_place_type_t<t_TYPE>,
    const t_ARG_01& arg_01,
    const t_ARG_02& arg_02,
    const t_ARG_03& arg_03,
    const t_ARG_04& arg_04,
    const t_ARG_05& arg_05,
    const t_ARG_06& arg_06,
    const t_ARG_07& arg_07,
    const t_ARG_08& arg_08,
    const t_ARG_09& arg_09,
    const t_ARG_10& arg_10,
    BSLSTL_VARIANT_DEFINE_IF_HAS_UNIQUE_TYPE(t_TYPE))
: Variant_Base(
      bsl::allocator_arg_t(),
      allocator,
      bsl::in_place_index_t<BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant)>(),
      arg_01,
      arg_02,
      arg_03,
      arg_04,
      arg_05,
      arg_06,
      arg_07,
      arg_08,
      arg_09,
      arg_10)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX>
inline
variant<t_HEAD, t_TAIL...>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>())
{
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX, class t_ARG_01>
inline
variant<t_HEAD, t_TAIL...>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
inline
variant<t_HEAD, t_TAIL...>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
inline
variant<t_HEAD, t_TAIL...>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
inline
variant<t_HEAD, t_TAIL...>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
inline
variant<t_HEAD, t_TAIL...>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
inline
variant<t_HEAD, t_TAIL...>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
inline
variant<t_HEAD, t_TAIL...>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
inline
variant<t_HEAD, t_TAIL...>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
inline
variant<t_HEAD, t_TAIL...>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
inline
variant<t_HEAD, t_TAIL...>::variant(bsl::allocator_arg_t,
                                    allocator_type allocator,
                                    bsl::in_place_index_t<t_INDEX>,
                                    const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
: Variant_Base(bsl::allocator_arg_t(),
               allocator,
               bsl::in_place_index_t<t_INDEX>(),
               arg_01,
               arg_02,
               arg_03,
               arg_04,
               arg_05,
               arg_06,
               arg_07,
               arg_08,
               arg_09,
               arg_10)
{
}
 
template <class t_HEAD, class... t_TAIL>
template <class t_TYPE>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL...> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL...>::emplace()
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>();
 
    return bsl::get<index>(*this);
}
 
template <class t_HEAD, class... t_TAIL>
template <class t_TYPE, class t_ARG_01>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL...> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL...>::emplace(const t_ARG_01& arg_01)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01);
 
    return bsl::get<index>(*this);
}
 
template <class t_HEAD, class... t_TAIL>
template <class t_TYPE, class t_ARG_01, class t_ARG_02>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL...> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL...>::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02);
 
    return bsl::get<index>(*this);
}
 
template <class t_HEAD, class... t_TAIL>
template <class t_TYPE, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL...> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL...>::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03);
 
    return bsl::get<index>(*this);
}
 
template <class t_HEAD, class... t_TAIL>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL...> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL...>::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<index>(*this);
}
 
template <class t_HEAD, class... t_TAIL>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL...> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL...>::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<index>(*this);
}
 
template <class t_HEAD, class... t_TAIL>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL...> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL...>::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<index>(*this);
}
 
template <class t_HEAD, class... t_TAIL>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL...> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL...>::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<index>(*this);
}
 
template <class t_HEAD, class... t_TAIL>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL...> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL...>::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<index>(*this);
}
 
template <class t_HEAD, class... t_TAIL>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL...> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL...>::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09);
 
    return bsl::get<index>(*this);
}
 
template <class t_HEAD, class... t_TAIL>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename bsl::enable_if<BloombergLP::bslstl::Variant_HasUniqueType<
                            t_TYPE,
                            variant<t_HEAD, t_TAIL...> >::value,
                        t_TYPE&>::type
variant<t_HEAD, t_TAIL...>::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    const size_t index = BSLSTL_VARIANT_INDEX_OF(t_TYPE, variant);
 
    Variant_Base::template baseEmplace<index>(arg_01,
                                              arg_02,
                                              arg_03,
                                              arg_04,
                                              arg_05,
                                              arg_06,
                                              arg_07,
                                              arg_08,
                                              arg_09,
                                              arg_10);
 
    return bsl::get<index>(*this);
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL...> >::type&
variant<t_HEAD, t_TAIL...>::emplace()
{
    Variant_Base::template baseEmplace<t_INDEX>();
 
    return bsl::get<t_INDEX>(*this);
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX, class t_ARG_01>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL...> >::type&
variant<t_HEAD, t_TAIL...>::emplace(const t_ARG_01& arg_01)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01);
 
    return bsl::get<t_INDEX>(*this);
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL...> >::type&
variant<t_HEAD, t_TAIL...>::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02);
 
    return bsl::get<t_INDEX>(*this);
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX, class t_ARG_01, class t_ARG_02, class t_ARG_03>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL...> >::type&
variant<t_HEAD, t_TAIL...>::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01, arg_02, arg_03);
 
    return bsl::get<t_INDEX>(*this);
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL...> >::type&
variant<t_HEAD, t_TAIL...>::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04);
 
    return bsl::get<t_INDEX>(*this);
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL...> >::type&
variant<t_HEAD, t_TAIL...>::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05);
 
    return bsl::get<t_INDEX>(*this);
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL...> >::type&
variant<t_HEAD, t_TAIL...>::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06);
 
    return bsl::get<t_INDEX>(*this);
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL...> >::type&
variant<t_HEAD, t_TAIL...>::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07);
 
    return bsl::get<t_INDEX>(*this);
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL...> >::type&
variant<t_HEAD, t_TAIL...>::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08)
{
    Variant_Base::template baseEmplace<t_INDEX>(
        arg_01, arg_02, arg_03, arg_04, arg_05, arg_06, arg_07, arg_08);
 
    return bsl::get<t_INDEX>(*this);
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL...> >::type&
variant<t_HEAD, t_TAIL...>::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09);
 
    return bsl::get<t_INDEX>(*this);
}
 
template <class t_HEAD, class... t_TAIL>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          class t_ARG_05,
          class t_ARG_06,
          class t_ARG_07,
          class t_ARG_08,
          class t_ARG_09,
          class t_ARG_10>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL...> >::type&
variant<t_HEAD, t_TAIL...>::emplace(const t_ARG_01& arg_01,
                                    const t_ARG_02& arg_02,
                                    const t_ARG_03& arg_03,
                                    const t_ARG_04& arg_04,
                                    const t_ARG_05& arg_05,
                                    const t_ARG_06& arg_06,
                                    const t_ARG_07& arg_07,
                                    const t_ARG_08& arg_08,
                                    const t_ARG_09& arg_09,
                                    const t_ARG_10& arg_10)
{
    Variant_Base::template baseEmplace<t_INDEX>(arg_01,
                                                arg_02,
                                                arg_03,
                                                arg_04,
                                                arg_05,
                                                arg_06,
                                                arg_07,
                                                arg_08,
                                                arg_09,
                                                arg_10);
 
    return bsl::get<t_INDEX>(*this);
}
 
template <class t_HEAD, class... t_TAIL>
inline
variant<t_HEAD, t_TAIL...>& variant<t_HEAD, t_TAIL...>::operator=(
                                                            const variant& rhs)
{
    Variant_Base::operator=(static_cast<const Variant_Base&>(rhs));
    return *this;
}
 
template <class t_HEAD, class... t_TAIL>
inline
variant<t_HEAD, t_TAIL...>& variant<t_HEAD, t_TAIL...>::operator=(
                                   BloombergLP::bslmf::MovableRef<variant> rhs)
{
    variant<t_HEAD, t_TAIL...>& lvalue = rhs;
    Variant_Base::operator=(
                           MoveUtil::move(static_cast<Variant_Base&>(lvalue)));
    return *this;
}
template <class t_HEAD, class... t_TAIL>
template <class t_TYPE>
inline
typename bsl::enable_if<
    BloombergLP::bslstl::Variant_AssignsFromType<variant<t_HEAD, t_TAIL...>,
                                                 t_TYPE>::value,
    variant<t_HEAD, t_TAIL...>&>::type
variant<t_HEAD, t_TAIL...>::operator=(const t_TYPE& rhs)
{
    const size_t altIndex = BSLSTL_VARIANT_CONVERT_INDEX_OF(t_TYPE, variant);
 
    if (index() == altIndex) {
        bsl::get<altIndex>(*this) = rhs;
    }
    else {
        emplace<altIndex>(rhs);
    }
 
    return *this;
}
// }}} END GENERATED CODE
#endif
#endif  // BSL_VARIANT_FULL_IMPLEMENTATION
 
#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
// {{{ BEGIN GENERATED CODE
// Command line: sim_cpp11_features.pl bslstl_variant.h
#ifndef BSLSTL_VARIANT_VARIADIC_LIMIT
#define BSLSTL_VARIANT_VARIADIC_LIMIT 18
#endif
#ifndef BSLSTL_VARIANT_VARIADIC_LIMIT_Q
#define BSLSTL_VARIANT_VARIADIC_LIMIT_Q BSLSTL_VARIANT_VARIADIC_LIMIT
#endif
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 0
template <class t_HEAD>
inline
void variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::swap(variant& other)
{
    if (!valueless_by_exception()) {
        if (index() == other.index()) {
            BloombergLP::bslstl::Variant_SwapVisitor<variant> swapper(this);
            BSLSTL_VARIANT_VISITID(void, swapper, other);
        }
        else {
            variant tmpThis(MoveUtil::move(*this));
            this->reset();
            if (!other.valueless_by_exception()) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
            }
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(BSLS_UTIL_ADDRESSOF(other));
            BSLSTL_VARIANT_VISITID(void, moveConstructor, tmpThis);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            other.d_type = tmpThis.index();
#endif
        }
    }
    else {
        if (!other.valueless_by_exception()) {
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                moveConstructor(this);
            BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
        }
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 1
template <class t_HEAD, class t_TAIL_01>
inline
void variant<t_HEAD, t_TAIL_01,
                     BSLS_COMPILERFEATURES_FILLT(17)>::swap(variant& other)
{
    if (!valueless_by_exception()) {
        if (index() == other.index()) {
            BloombergLP::bslstl::Variant_SwapVisitor<variant> swapper(this);
            BSLSTL_VARIANT_VISITID(void, swapper, other);
        }
        else {
            variant tmpThis(MoveUtil::move(*this));
            this->reset();
            if (!other.valueless_by_exception()) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
            }
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(BSLS_UTIL_ADDRESSOF(other));
            BSLSTL_VARIANT_VISITID(void, moveConstructor, tmpThis);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            other.d_type = tmpThis.index();
#endif
        }
    }
    else {
        if (!other.valueless_by_exception()) {
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                moveConstructor(this);
            BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
        }
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
inline
void variant<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     BSLS_COMPILERFEATURES_FILLT(16)>::swap(variant& other)
{
    if (!valueless_by_exception()) {
        if (index() == other.index()) {
            BloombergLP::bslstl::Variant_SwapVisitor<variant> swapper(this);
            BSLSTL_VARIANT_VISITID(void, swapper, other);
        }
        else {
            variant tmpThis(MoveUtil::move(*this));
            this->reset();
            if (!other.valueless_by_exception()) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
            }
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(BSLS_UTIL_ADDRESSOF(other));
            BSLSTL_VARIANT_VISITID(void, moveConstructor, tmpThis);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            other.d_type = tmpThis.index();
#endif
        }
    }
    else {
        if (!other.valueless_by_exception()) {
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                moveConstructor(this);
            BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
        }
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
inline
void variant<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     BSLS_COMPILERFEATURES_FILLT(15)>::swap(variant& other)
{
    if (!valueless_by_exception()) {
        if (index() == other.index()) {
            BloombergLP::bslstl::Variant_SwapVisitor<variant> swapper(this);
            BSLSTL_VARIANT_VISITID(void, swapper, other);
        }
        else {
            variant tmpThis(MoveUtil::move(*this));
            this->reset();
            if (!other.valueless_by_exception()) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
            }
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(BSLS_UTIL_ADDRESSOF(other));
            BSLSTL_VARIANT_VISITID(void, moveConstructor, tmpThis);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            other.d_type = tmpThis.index();
#endif
        }
    }
    else {
        if (!other.valueless_by_exception()) {
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                moveConstructor(this);
            BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
        }
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
inline
void variant<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     BSLS_COMPILERFEATURES_FILLT(14)>::swap(variant& other)
{
    if (!valueless_by_exception()) {
        if (index() == other.index()) {
            BloombergLP::bslstl::Variant_SwapVisitor<variant> swapper(this);
            BSLSTL_VARIANT_VISITID(void, swapper, other);
        }
        else {
            variant tmpThis(MoveUtil::move(*this));
            this->reset();
            if (!other.valueless_by_exception()) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
            }
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(BSLS_UTIL_ADDRESSOF(other));
            BSLSTL_VARIANT_VISITID(void, moveConstructor, tmpThis);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            other.d_type = tmpThis.index();
#endif
        }
    }
    else {
        if (!other.valueless_by_exception()) {
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                moveConstructor(this);
            BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
        }
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
inline
void variant<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     BSLS_COMPILERFEATURES_FILLT(13)>::swap(variant& other)
{
    if (!valueless_by_exception()) {
        if (index() == other.index()) {
            BloombergLP::bslstl::Variant_SwapVisitor<variant> swapper(this);
            BSLSTL_VARIANT_VISITID(void, swapper, other);
        }
        else {
            variant tmpThis(MoveUtil::move(*this));
            this->reset();
            if (!other.valueless_by_exception()) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
            }
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(BSLS_UTIL_ADDRESSOF(other));
            BSLSTL_VARIANT_VISITID(void, moveConstructor, tmpThis);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            other.d_type = tmpThis.index();
#endif
        }
    }
    else {
        if (!other.valueless_by_exception()) {
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                moveConstructor(this);
            BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
        }
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
inline
void variant<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     BSLS_COMPILERFEATURES_FILLT(12)>::swap(variant& other)
{
    if (!valueless_by_exception()) {
        if (index() == other.index()) {
            BloombergLP::bslstl::Variant_SwapVisitor<variant> swapper(this);
            BSLSTL_VARIANT_VISITID(void, swapper, other);
        }
        else {
            variant tmpThis(MoveUtil::move(*this));
            this->reset();
            if (!other.valueless_by_exception()) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
            }
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(BSLS_UTIL_ADDRESSOF(other));
            BSLSTL_VARIANT_VISITID(void, moveConstructor, tmpThis);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            other.d_type = tmpThis.index();
#endif
        }
    }
    else {
        if (!other.valueless_by_exception()) {
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                moveConstructor(this);
            BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
        }
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
inline
void variant<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     BSLS_COMPILERFEATURES_FILLT(11)>::swap(variant& other)
{
    if (!valueless_by_exception()) {
        if (index() == other.index()) {
            BloombergLP::bslstl::Variant_SwapVisitor<variant> swapper(this);
            BSLSTL_VARIANT_VISITID(void, swapper, other);
        }
        else {
            variant tmpThis(MoveUtil::move(*this));
            this->reset();
            if (!other.valueless_by_exception()) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
            }
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(BSLS_UTIL_ADDRESSOF(other));
            BSLSTL_VARIANT_VISITID(void, moveConstructor, tmpThis);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            other.d_type = tmpThis.index();
#endif
        }
    }
    else {
        if (!other.valueless_by_exception()) {
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                moveConstructor(this);
            BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
        }
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
inline
void variant<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     BSLS_COMPILERFEATURES_FILLT(10)>::swap(variant& other)
{
    if (!valueless_by_exception()) {
        if (index() == other.index()) {
            BloombergLP::bslstl::Variant_SwapVisitor<variant> swapper(this);
            BSLSTL_VARIANT_VISITID(void, swapper, other);
        }
        else {
            variant tmpThis(MoveUtil::move(*this));
            this->reset();
            if (!other.valueless_by_exception()) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
            }
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(BSLS_UTIL_ADDRESSOF(other));
            BSLSTL_VARIANT_VISITID(void, moveConstructor, tmpThis);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            other.d_type = tmpThis.index();
#endif
        }
    }
    else {
        if (!other.valueless_by_exception()) {
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                moveConstructor(this);
            BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
        }
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
inline
void variant<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     BSLS_COMPILERFEATURES_FILLT( 9)>::swap(variant& other)
{
    if (!valueless_by_exception()) {
        if (index() == other.index()) {
            BloombergLP::bslstl::Variant_SwapVisitor<variant> swapper(this);
            BSLSTL_VARIANT_VISITID(void, swapper, other);
        }
        else {
            variant tmpThis(MoveUtil::move(*this));
            this->reset();
            if (!other.valueless_by_exception()) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
            }
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(BSLS_UTIL_ADDRESSOF(other));
            BSLSTL_VARIANT_VISITID(void, moveConstructor, tmpThis);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            other.d_type = tmpThis.index();
#endif
        }
    }
    else {
        if (!other.valueless_by_exception()) {
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                moveConstructor(this);
            BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
        }
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
inline
void variant<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     BSLS_COMPILERFEATURES_FILLT( 8)>::swap(variant& other)
{
    if (!valueless_by_exception()) {
        if (index() == other.index()) {
            BloombergLP::bslstl::Variant_SwapVisitor<variant> swapper(this);
            BSLSTL_VARIANT_VISITID(void, swapper, other);
        }
        else {
            variant tmpThis(MoveUtil::move(*this));
            this->reset();
            if (!other.valueless_by_exception()) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
            }
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(BSLS_UTIL_ADDRESSOF(other));
            BSLSTL_VARIANT_VISITID(void, moveConstructor, tmpThis);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            other.d_type = tmpThis.index();
#endif
        }
    }
    else {
        if (!other.valueless_by_exception()) {
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                moveConstructor(this);
            BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
        }
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
inline
void variant<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     BSLS_COMPILERFEATURES_FILLT( 7)>::swap(variant& other)
{
    if (!valueless_by_exception()) {
        if (index() == other.index()) {
            BloombergLP::bslstl::Variant_SwapVisitor<variant> swapper(this);
            BSLSTL_VARIANT_VISITID(void, swapper, other);
        }
        else {
            variant tmpThis(MoveUtil::move(*this));
            this->reset();
            if (!other.valueless_by_exception()) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
            }
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(BSLS_UTIL_ADDRESSOF(other));
            BSLSTL_VARIANT_VISITID(void, moveConstructor, tmpThis);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            other.d_type = tmpThis.index();
#endif
        }
    }
    else {
        if (!other.valueless_by_exception()) {
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                moveConstructor(this);
            BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
        }
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
inline
void variant<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     BSLS_COMPILERFEATURES_FILLT( 6)>::swap(variant& other)
{
    if (!valueless_by_exception()) {
        if (index() == other.index()) {
            BloombergLP::bslstl::Variant_SwapVisitor<variant> swapper(this);
            BSLSTL_VARIANT_VISITID(void, swapper, other);
        }
        else {
            variant tmpThis(MoveUtil::move(*this));
            this->reset();
            if (!other.valueless_by_exception()) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
            }
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(BSLS_UTIL_ADDRESSOF(other));
            BSLSTL_VARIANT_VISITID(void, moveConstructor, tmpThis);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            other.d_type = tmpThis.index();
#endif
        }
    }
    else {
        if (!other.valueless_by_exception()) {
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                moveConstructor(this);
            BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
        }
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
inline
void variant<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     BSLS_COMPILERFEATURES_FILLT( 5)>::swap(variant& other)
{
    if (!valueless_by_exception()) {
        if (index() == other.index()) {
            BloombergLP::bslstl::Variant_SwapVisitor<variant> swapper(this);
            BSLSTL_VARIANT_VISITID(void, swapper, other);
        }
        else {
            variant tmpThis(MoveUtil::move(*this));
            this->reset();
            if (!other.valueless_by_exception()) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
            }
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(BSLS_UTIL_ADDRESSOF(other));
            BSLSTL_VARIANT_VISITID(void, moveConstructor, tmpThis);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            other.d_type = tmpThis.index();
#endif
        }
    }
    else {
        if (!other.valueless_by_exception()) {
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                moveConstructor(this);
            BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
        }
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
inline
void variant<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     BSLS_COMPILERFEATURES_FILLT( 4)>::swap(variant& other)
{
    if (!valueless_by_exception()) {
        if (index() == other.index()) {
            BloombergLP::bslstl::Variant_SwapVisitor<variant> swapper(this);
            BSLSTL_VARIANT_VISITID(void, swapper, other);
        }
        else {
            variant tmpThis(MoveUtil::move(*this));
            this->reset();
            if (!other.valueless_by_exception()) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
            }
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(BSLS_UTIL_ADDRESSOF(other));
            BSLSTL_VARIANT_VISITID(void, moveConstructor, tmpThis);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            other.d_type = tmpThis.index();
#endif
        }
    }
    else {
        if (!other.valueless_by_exception()) {
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                moveConstructor(this);
            BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
        }
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
inline
void variant<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     BSLS_COMPILERFEATURES_FILLT( 3)>::swap(variant& other)
{
    if (!valueless_by_exception()) {
        if (index() == other.index()) {
            BloombergLP::bslstl::Variant_SwapVisitor<variant> swapper(this);
            BSLSTL_VARIANT_VISITID(void, swapper, other);
        }
        else {
            variant tmpThis(MoveUtil::move(*this));
            this->reset();
            if (!other.valueless_by_exception()) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
            }
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(BSLS_UTIL_ADDRESSOF(other));
            BSLSTL_VARIANT_VISITID(void, moveConstructor, tmpThis);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            other.d_type = tmpThis.index();
#endif
        }
    }
    else {
        if (!other.valueless_by_exception()) {
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                moveConstructor(this);
            BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
        }
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
inline
void variant<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     BSLS_COMPILERFEATURES_FILLT( 2)>::swap(variant& other)
{
    if (!valueless_by_exception()) {
        if (index() == other.index()) {
            BloombergLP::bslstl::Variant_SwapVisitor<variant> swapper(this);
            BSLSTL_VARIANT_VISITID(void, swapper, other);
        }
        else {
            variant tmpThis(MoveUtil::move(*this));
            this->reset();
            if (!other.valueless_by_exception()) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
            }
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(BSLS_UTIL_ADDRESSOF(other));
            BSLSTL_VARIANT_VISITID(void, moveConstructor, tmpThis);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            other.d_type = tmpThis.index();
#endif
        }
    }
    else {
        if (!other.valueless_by_exception()) {
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                moveConstructor(this);
            BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
        }
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
inline
void variant<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     BSLS_COMPILERFEATURES_FILLT( 1)>::swap(variant& other)
{
    if (!valueless_by_exception()) {
        if (index() == other.index()) {
            BloombergLP::bslstl::Variant_SwapVisitor<variant> swapper(this);
            BSLSTL_VARIANT_VISITID(void, swapper, other);
        }
        else {
            variant tmpThis(MoveUtil::move(*this));
            this->reset();
            if (!other.valueless_by_exception()) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
            }
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(BSLS_UTIL_ADDRESSOF(other));
            BSLSTL_VARIANT_VISITID(void, moveConstructor, tmpThis);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            other.d_type = tmpThis.index();
#endif
        }
    }
    else {
        if (!other.valueless_by_exception()) {
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                moveConstructor(this);
            BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
        }
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
inline
void variant<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     t_TAIL_18,
                     BSLS_COMPILERFEATURES_FILLT( 0)>::swap(variant& other)
{
    if (!valueless_by_exception()) {
        if (index() == other.index()) {
            BloombergLP::bslstl::Variant_SwapVisitor<variant> swapper(this);
            BSLSTL_VARIANT_VISITID(void, swapper, other);
        }
        else {
            variant tmpThis(MoveUtil::move(*this));
            this->reset();
            if (!other.valueless_by_exception()) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
            }
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(BSLS_UTIL_ADDRESSOF(other));
            BSLSTL_VARIANT_VISITID(void, moveConstructor, tmpThis);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            other.d_type = tmpThis.index();
#endif
        }
    }
    else {
        if (!other.valueless_by_exception()) {
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                moveConstructor(this);
            BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
        }
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 0
template <class t_HEAD>
inline
size_t variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)
                       >::index() const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 1
template <class t_HEAD, class t_TAIL_01>
inline
size_t variant<t_HEAD, t_TAIL_01,
                       BSLS_COMPILERFEATURES_FILLT(17)
                       >::index() const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
inline
size_t variant<t_HEAD, t_TAIL_01,
                       t_TAIL_02,
                       BSLS_COMPILERFEATURES_FILLT(16)
                       >::index() const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
inline
size_t variant<t_HEAD, t_TAIL_01,
                       t_TAIL_02,
                       t_TAIL_03,
                       BSLS_COMPILERFEATURES_FILLT(15)
                       >::index() const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
inline
size_t variant<t_HEAD, t_TAIL_01,
                       t_TAIL_02,
                       t_TAIL_03,
                       t_TAIL_04,
                       BSLS_COMPILERFEATURES_FILLT(14)
                       >::index() const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
inline
size_t variant<t_HEAD, t_TAIL_01,
                       t_TAIL_02,
                       t_TAIL_03,
                       t_TAIL_04,
                       t_TAIL_05,
                       BSLS_COMPILERFEATURES_FILLT(13)
                       >::index() const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
inline
size_t variant<t_HEAD, t_TAIL_01,
                       t_TAIL_02,
                       t_TAIL_03,
                       t_TAIL_04,
                       t_TAIL_05,
                       t_TAIL_06,
                       BSLS_COMPILERFEATURES_FILLT(12)
                       >::index() const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
inline
size_t variant<t_HEAD, t_TAIL_01,
                       t_TAIL_02,
                       t_TAIL_03,
                       t_TAIL_04,
                       t_TAIL_05,
                       t_TAIL_06,
                       t_TAIL_07,
                       BSLS_COMPILERFEATURES_FILLT(11)
                       >::index() const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
inline
size_t variant<t_HEAD, t_TAIL_01,
                       t_TAIL_02,
                       t_TAIL_03,
                       t_TAIL_04,
                       t_TAIL_05,
                       t_TAIL_06,
                       t_TAIL_07,
                       t_TAIL_08,
                       BSLS_COMPILERFEATURES_FILLT(10)
                       >::index() const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
inline
size_t variant<t_HEAD, t_TAIL_01,
                       t_TAIL_02,
                       t_TAIL_03,
                       t_TAIL_04,
                       t_TAIL_05,
                       t_TAIL_06,
                       t_TAIL_07,
                       t_TAIL_08,
                       t_TAIL_09,
                       BSLS_COMPILERFEATURES_FILLT( 9)
                       >::index() const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
inline
size_t variant<t_HEAD, t_TAIL_01,
                       t_TAIL_02,
                       t_TAIL_03,
                       t_TAIL_04,
                       t_TAIL_05,
                       t_TAIL_06,
                       t_TAIL_07,
                       t_TAIL_08,
                       t_TAIL_09,
                       t_TAIL_10,
                       BSLS_COMPILERFEATURES_FILLT( 8)
                       >::index() const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
inline
size_t variant<t_HEAD, t_TAIL_01,
                       t_TAIL_02,
                       t_TAIL_03,
                       t_TAIL_04,
                       t_TAIL_05,
                       t_TAIL_06,
                       t_TAIL_07,
                       t_TAIL_08,
                       t_TAIL_09,
                       t_TAIL_10,
                       t_TAIL_11,
                       BSLS_COMPILERFEATURES_FILLT( 7)
                       >::index() const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
inline
size_t variant<t_HEAD, t_TAIL_01,
                       t_TAIL_02,
                       t_TAIL_03,
                       t_TAIL_04,
                       t_TAIL_05,
                       t_TAIL_06,
                       t_TAIL_07,
                       t_TAIL_08,
                       t_TAIL_09,
                       t_TAIL_10,
                       t_TAIL_11,
                       t_TAIL_12,
                       BSLS_COMPILERFEATURES_FILLT( 6)
                       >::index() const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
inline
size_t variant<t_HEAD, t_TAIL_01,
                       t_TAIL_02,
                       t_TAIL_03,
                       t_TAIL_04,
                       t_TAIL_05,
                       t_TAIL_06,
                       t_TAIL_07,
                       t_TAIL_08,
                       t_TAIL_09,
                       t_TAIL_10,
                       t_TAIL_11,
                       t_TAIL_12,
                       t_TAIL_13,
                       BSLS_COMPILERFEATURES_FILLT( 5)
                       >::index() const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
inline
size_t variant<t_HEAD, t_TAIL_01,
                       t_TAIL_02,
                       t_TAIL_03,
                       t_TAIL_04,
                       t_TAIL_05,
                       t_TAIL_06,
                       t_TAIL_07,
                       t_TAIL_08,
                       t_TAIL_09,
                       t_TAIL_10,
                       t_TAIL_11,
                       t_TAIL_12,
                       t_TAIL_13,
                       t_TAIL_14,
                       BSLS_COMPILERFEATURES_FILLT( 4)
                       >::index() const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
inline
size_t variant<t_HEAD, t_TAIL_01,
                       t_TAIL_02,
                       t_TAIL_03,
                       t_TAIL_04,
                       t_TAIL_05,
                       t_TAIL_06,
                       t_TAIL_07,
                       t_TAIL_08,
                       t_TAIL_09,
                       t_TAIL_10,
                       t_TAIL_11,
                       t_TAIL_12,
                       t_TAIL_13,
                       t_TAIL_14,
                       t_TAIL_15,
                       BSLS_COMPILERFEATURES_FILLT( 3)
                       >::index() const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
inline
size_t variant<t_HEAD, t_TAIL_01,
                       t_TAIL_02,
                       t_TAIL_03,
                       t_TAIL_04,
                       t_TAIL_05,
                       t_TAIL_06,
                       t_TAIL_07,
                       t_TAIL_08,
                       t_TAIL_09,
                       t_TAIL_10,
                       t_TAIL_11,
                       t_TAIL_12,
                       t_TAIL_13,
                       t_TAIL_14,
                       t_TAIL_15,
                       t_TAIL_16,
                       BSLS_COMPILERFEATURES_FILLT( 2)
                       >::index() const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
inline
size_t variant<t_HEAD, t_TAIL_01,
                       t_TAIL_02,
                       t_TAIL_03,
                       t_TAIL_04,
                       t_TAIL_05,
                       t_TAIL_06,
                       t_TAIL_07,
                       t_TAIL_08,
                       t_TAIL_09,
                       t_TAIL_10,
                       t_TAIL_11,
                       t_TAIL_12,
                       t_TAIL_13,
                       t_TAIL_14,
                       t_TAIL_15,
                       t_TAIL_16,
                       t_TAIL_17,
                       BSLS_COMPILERFEATURES_FILLT( 1)
                       >::index() const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
inline
size_t variant<t_HEAD, t_TAIL_01,
                       t_TAIL_02,
                       t_TAIL_03,
                       t_TAIL_04,
                       t_TAIL_05,
                       t_TAIL_06,
                       t_TAIL_07,
                       t_TAIL_08,
                       t_TAIL_09,
                       t_TAIL_10,
                       t_TAIL_11,
                       t_TAIL_12,
                       t_TAIL_13,
                       t_TAIL_14,
                       t_TAIL_15,
                       t_TAIL_16,
                       t_TAIL_17,
                       t_TAIL_18,
                       BSLS_COMPILERFEATURES_FILLT( 0)
                       >::index() const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 0
template <class t_HEAD>
inline
bool variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::valueless_by_exception()
const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type == bsl::variant_npos;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 1
template <class t_HEAD, class t_TAIL_01>
inline
bool variant<t_HEAD, t_TAIL_01,
                     BSLS_COMPILERFEATURES_FILLT(17)>::valueless_by_exception()
const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type == bsl::variant_npos;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
inline
bool variant<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     BSLS_COMPILERFEATURES_FILLT(16)>::valueless_by_exception()
const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type == bsl::variant_npos;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
inline
bool variant<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     BSLS_COMPILERFEATURES_FILLT(15)>::valueless_by_exception()
const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type == bsl::variant_npos;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
inline
bool variant<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     BSLS_COMPILERFEATURES_FILLT(14)>::valueless_by_exception()
const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type == bsl::variant_npos;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
inline
bool variant<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     BSLS_COMPILERFEATURES_FILLT(13)>::valueless_by_exception()
const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type == bsl::variant_npos;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
inline
bool variant<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     BSLS_COMPILERFEATURES_FILLT(12)>::valueless_by_exception()
const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type == bsl::variant_npos;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
inline
bool variant<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     BSLS_COMPILERFEATURES_FILLT(11)>::valueless_by_exception()
const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type == bsl::variant_npos;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
inline
bool variant<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     BSLS_COMPILERFEATURES_FILLT(10)>::valueless_by_exception()
const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type == bsl::variant_npos;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
inline
bool variant<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     BSLS_COMPILERFEATURES_FILLT( 9)>::valueless_by_exception()
const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type == bsl::variant_npos;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
inline
bool variant<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     BSLS_COMPILERFEATURES_FILLT( 8)>::valueless_by_exception()
const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type == bsl::variant_npos;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
inline
bool variant<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     BSLS_COMPILERFEATURES_FILLT( 7)>::valueless_by_exception()
const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type == bsl::variant_npos;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
inline
bool variant<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     BSLS_COMPILERFEATURES_FILLT( 6)>::valueless_by_exception()
const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type == bsl::variant_npos;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
inline
bool variant<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     BSLS_COMPILERFEATURES_FILLT( 5)>::valueless_by_exception()
const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type == bsl::variant_npos;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
inline
bool variant<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     BSLS_COMPILERFEATURES_FILLT( 4)>::valueless_by_exception()
const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type == bsl::variant_npos;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
inline
bool variant<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     BSLS_COMPILERFEATURES_FILLT( 3)>::valueless_by_exception()
const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type == bsl::variant_npos;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
inline
bool variant<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     BSLS_COMPILERFEATURES_FILLT( 2)>::valueless_by_exception()
const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type == bsl::variant_npos;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
inline
bool variant<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     BSLS_COMPILERFEATURES_FILLT( 1)>::valueless_by_exception()
const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type == bsl::variant_npos;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
inline
bool variant<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     t_TAIL_11,
                     t_TAIL_12,
                     t_TAIL_13,
                     t_TAIL_14,
                     t_TAIL_15,
                     t_TAIL_16,
                     t_TAIL_17,
                     t_TAIL_18,
                     BSLS_COMPILERFEATURES_FILLT( 0)>::valueless_by_exception()
const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type == bsl::variant_npos;
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 18
 
#else
// The generated code below is a workaround for the absence of perfect
// forwarding in some compilers.
template <class t_HEAD, class... t_TAIL>
inline
void variant<t_HEAD, t_TAIL...>::swap(variant& other)
{
    if (!valueless_by_exception()) {
        if (index() == other.index()) {
            BloombergLP::bslstl::Variant_SwapVisitor<variant> swapper(this);
            BSLSTL_VARIANT_VISITID(void, swapper, other);
        }
        else {
            variant tmpThis(MoveUtil::move(*this));
            this->reset();
            if (!other.valueless_by_exception()) {
                BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                    moveConstructor(this);
                BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
            }
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
            moveConstructor(BSLS_UTIL_ADDRESSOF(other));
            BSLSTL_VARIANT_VISITID(void, moveConstructor, tmpThis);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            other.d_type = tmpThis.index();
#endif
        }
    }
    else {
        if (!other.valueless_by_exception()) {
            BloombergLP::bslstl::Variant_MoveConstructVisitor<Variant_Base>
                moveConstructor(this);
            BSLSTL_VARIANT_VISITID(void, moveConstructor, other);
#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
            this->d_type = other.index();
#endif
            other.reset();
        }
    }
}
 
template <class t_HEAD, class... t_TAIL>
inline
size_t variant<t_HEAD, t_TAIL...>::index() const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type;
}
 
template <class t_HEAD, class... t_TAIL>
inline
bool variant<t_HEAD, t_TAIL...>::valueless_by_exception()
const BSLS_KEYWORD_NOEXCEPT
{
    return this->d_type == bsl::variant_npos;
}
 
// }}} END GENERATED CODE
#endif
 
// FREE FUNCTIONS
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
template <size_t t_INDEX, class t_HEAD, class... t_TAIL>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL...> >::type& get(
                                               variant<t_HEAD, t_TAIL...>& obj)
{
    BSLMF_ASSERT((t_INDEX < variant_size<variant<t_HEAD, t_TAIL...> >::value));
 
    typedef typename bsl::variant<t_HEAD, t_TAIL...>                  Variant;
    typedef BloombergLP::bslstl::Variant_ImpUtil                      ImpUtil;
    typedef typename bsl::variant_alternative<t_INDEX, Variant>::type Ret;
 
    return ImpUtil::get<Ret, t_INDEX>(obj);
}
 
template <size_t t_INDEX, class t_HEAD, class... t_TAIL>
const typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL...> >::type&
get(const variant<t_HEAD, t_TAIL...>& obj)
{
    BSLMF_ASSERT((t_INDEX < variant_size<variant<t_HEAD, t_TAIL...> >::value));
 
    typedef typename bsl::variant<t_HEAD, t_TAIL...>                  Variant;
    typedef BloombergLP::bslstl::Variant_ImpUtil                      ImpUtil;
    typedef typename bsl::variant_alternative<t_INDEX, Variant>::type Ret;
 
    return ImpUtil::get<const Ret, t_INDEX>(obj);
}
 
template <size_t t_INDEX, class t_HEAD, class... t_TAIL>
typename variant_alternative<t_INDEX, variant<t_HEAD, t_TAIL...> >::type&& get(
                                              variant<t_HEAD, t_TAIL...>&& obj)
{
    BSLMF_ASSERT((t_INDEX < variant_size<variant<t_HEAD, t_TAIL...> >::value));
 
    typedef typename bsl::variant<t_HEAD, t_TAIL...>                  Variant;
    typedef BloombergLP::bslstl::Variant_ImpUtil                      ImpUtil;
    typedef typename bsl::variant_alternative<t_INDEX, Variant>::type Ret;
 
    return std::move(ImpUtil::get<Ret, t_INDEX>(obj));
}
 
template <size_t t_INDEX, class t_HEAD, class... t_TAIL>
const typename variant_alternative<t_INDEX,
                                   variant<t_HEAD, t_TAIL...> >::type&&
get(const variant<t_HEAD, t_TAIL...>&& obj)
{
    BSLMF_ASSERT((t_INDEX < variant_size<variant<t_HEAD, t_TAIL...> >::value));
 
    typedef typename bsl::variant<t_HEAD, t_TAIL...>                  Variant;
    typedef BloombergLP::bslstl::Variant_ImpUtil                      ImpUtil;
    typedef typename bsl::variant_alternative<t_INDEX, Variant>::type Ret;
 
    return std::move(ImpUtil::get<const Ret, t_INDEX>(obj));
}
#else  // BSL_VARIANT_FULL_IMPLEMENTATION
// {{{ BEGIN GENERATED CODE
// The generated code below is a workaround for the absence of perfect
// forwarding in some compilers.
template <size_t t_INDEX, class t_VARIANT>
typename Variant_GetIndexReturnType<t_INDEX, t_VARIANT>::type
get(t_VARIANT& obj)
{
    BSLMF_ASSERT((t_INDEX < variant_size<t_VARIANT>::value));
 
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
    typedef typename bsl::variant_alternative<t_INDEX, t_VARIANT>::type Ret;
 
    return ImpUtil::get<Ret, t_INDEX>(obj);
}
 
template <size_t t_INDEX, class t_VARIANT>
typename Variant_GetIndexReturnType<
    t_INDEX,
    BloombergLP::bslmf::MovableRef<t_VARIANT> >::type
get(BloombergLP::bslmf::MovableRef<t_VARIANT> obj)
{
    typedef BloombergLP::bslmf::MovableRefUtil   MoveUtil;
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
    typedef typename bsl::variant_alternative<t_INDEX, t_VARIANT>::type Ret;
 
    t_VARIANT& lvalue = obj;
 
    return MoveUtil::move(ImpUtil::get<Ret, t_INDEX>(lvalue));
}
// }}} END GENERATED CODE
#endif  // BSL_VARIANT_FULL_IMPLEMENTATION
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
template <class t_TYPE, class t_HEAD, class... t_TAIL>
t_TYPE& get(variant<t_HEAD, t_TAIL...>& obj)
{
    BSLMF_ASSERT((BloombergLP::bslstl::Variant_HasUniqueType<
                  t_TYPE,
                  variant<t_HEAD, t_TAIL...> >::value));
 
    typedef typename bsl::variant<t_HEAD, t_TAIL...> Variant;
    typedef BloombergLP::bslstl::Variant_ImpUtil     ImpUtil;
 
    return ImpUtil::get<t_TYPE, BSLSTL_VARIANT_INDEX_OF(t_TYPE, Variant)>(obj);
}
 
template <class t_TYPE, class t_HEAD, class... t_TAIL>
const t_TYPE& get(const variant<t_HEAD, t_TAIL...>& obj)
{
    BSLMF_ASSERT((BloombergLP::bslstl::Variant_HasUniqueType<
                  t_TYPE,
                  variant<t_HEAD, t_TAIL...> >::value));
 
    typedef typename bsl::variant<t_HEAD, t_TAIL...> Variant;
    typedef BloombergLP::bslstl::Variant_ImpUtil     ImpUtil;
 
    return ImpUtil::get<const t_TYPE,
                        BSLSTL_VARIANT_INDEX_OF(t_TYPE, Variant)>(obj);
}
 
template <class t_TYPE, class t_HEAD, class... t_TAIL>
t_TYPE&& get(variant<t_HEAD, t_TAIL...>&& obj)
{
    static_assert(
        BloombergLP::bslstl::
            Variant_HasUniqueType<t_TYPE, variant<t_HEAD, t_TAIL...> >::value,
        "Type is not unique in variant");
 
    typedef typename bsl::variant<t_HEAD, t_TAIL...> Variant;
    typedef BloombergLP::bslstl::Variant_ImpUtil     ImpUtil;
 
    return std::move(
          ImpUtil::get<t_TYPE, BSLSTL_VARIANT_INDEX_OF(t_TYPE, Variant)>(obj));
}
 
template <class t_TYPE, class t_HEAD, class... t_TAIL>
const t_TYPE&& get(const variant<t_HEAD, t_TAIL...>&& obj)
{
    static_assert(
        BloombergLP::bslstl::
            Variant_HasUniqueType<t_TYPE, variant<t_HEAD, t_TAIL...> >::value,
        "Type is not unique in variant");
 
    typedef typename bsl::variant<t_HEAD, t_TAIL...> Variant;
    typedef BloombergLP::bslstl::Variant_ImpUtil     ImpUtil;
 
    return std::move(
          ImpUtil::get<const t_TYPE, BSLSTL_VARIANT_INDEX_OF(t_TYPE, Variant)>(
              obj));
}
#else  // BSL_VARIANT_FULL_IMPLEMENTATION
// {{{ BEGIN GENERATED CODE
// The generated code below is a workaround for the absence of perfect
// forwarding in some compilers.
template <class t_TYPE, class t_VARIANT>
typename Variant_GetTypeReturnType<t_TYPE&, t_VARIANT>::type
get(t_VARIANT& obj)
{
    BSLMF_ASSERT((
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, t_VARIANT>::value));
 
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    return ImpUtil::get<t_TYPE, BSLSTL_VARIANT_INDEX_OF(t_TYPE, t_VARIANT)>(
                                                                          obj);
}
 
template <class t_TYPE, class t_VARIANT>
typename Variant_GetTypeReturnType<const t_TYPE&, t_VARIANT>::type
get(const t_VARIANT& obj)
{
    BSLMF_ASSERT((
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, t_VARIANT>::value));
 
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    return ImpUtil::get<const t_TYPE,
                        BSLSTL_VARIANT_INDEX_OF(t_TYPE, t_VARIANT)>(obj);
}
 
template <class t_TYPE, class t_VARIANT>
typename Variant_GetTypeReturnType<BloombergLP::bslmf::MovableRef<t_TYPE>,
                                   t_VARIANT>::type
get(BloombergLP::bslmf::MovableRef<t_VARIANT> obj)
{
    BSLMF_ASSERT((
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, t_VARIANT>::value));
 
    typedef BloombergLP::bslmf::MovableRefUtil            MoveUtil;
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    t_VARIANT& lvalue = obj;
    return MoveUtil::move(
              ImpUtil::get<t_TYPE, BSLSTL_VARIANT_INDEX_OF(t_TYPE, t_VARIANT)>(
                  lvalue));
}
// }}} END GENERATED CODE
#endif  // BSL_VARIANT_FULL_IMPLEMENTATION
 
#ifdef BSL_VARIANT_FULL_IMPLEMENTATION
template <size_t t_INDEX, class t_HEAD, class... t_TAIL>
typename add_pointer<
    typename variant_alternative<t_INDEX,
                                 variant<t_HEAD, t_TAIL...> >::type>::type
get_if(variant<t_HEAD, t_TAIL...> *ptr) BSLS_KEYWORD_NOEXCEPT
{
    BSLMF_ASSERT((t_INDEX < variant_size<variant<t_HEAD, t_TAIL...> >::value));
 
    typedef typename bsl::variant<t_HEAD, t_TAIL...>                  Variant;
    typedef BloombergLP::bslstl::Variant_ImpUtil                      ImpUtil;
    typedef typename bsl::variant_alternative<t_INDEX, Variant>::type Ret;
 
    if (ptr == 0 || ptr->index() != t_INDEX) {
        return NULL;                                                  // RETURN
    }
 
    return BSLS_UTIL_ADDRESSOF((ImpUtil::get<Ret, t_INDEX>(*ptr)));
}
 
template <size_t t_INDEX, class t_HEAD, class... t_TAIL>
typename add_pointer<const typename variant_alternative<
    t_INDEX,
    variant<t_HEAD, t_TAIL...> >::type>::type
get_if(const variant<t_HEAD, t_TAIL...> *ptr) BSLS_KEYWORD_NOEXCEPT
{
    BSLMF_ASSERT((t_INDEX < variant_size<variant<t_HEAD, t_TAIL...> >::value));
 
    typedef typename bsl::variant<t_HEAD, t_TAIL...>                  Variant;
    typedef BloombergLP::bslstl::Variant_ImpUtil                      ImpUtil;
    typedef typename bsl::variant_alternative<t_INDEX, Variant>::type Ret;
 
    if (ptr == 0 || ptr->index() != t_INDEX) {
        return NULL;                                                  // RETURN
    }
    return BSLS_UTIL_ADDRESSOF((ImpUtil::get<const Ret, t_INDEX>(*ptr)));
}
 
template <class t_TYPE, class t_HEAD, class... t_TAIL>
typename add_pointer<t_TYPE>::type get_if(
                         variant<t_HEAD, t_TAIL...> *ptr) BSLS_KEYWORD_NOEXCEPT
{
    BSLMF_ASSERT((BloombergLP::bslstl::Variant_HasUniqueType<
                  t_TYPE,
                  variant<t_HEAD, t_TAIL...> >::value));
 
    typedef typename bsl::variant<t_HEAD, t_TAIL...> Variant;
    typedef BloombergLP::bslstl::Variant_ImpUtil     ImpUtil;
 
    if (ptr == 0 || ptr->index() != BSLSTL_VARIANT_INDEX_OF(t_TYPE, Variant)) {
        return NULL;                                                  // RETURN
    }
    return BSLS_UTIL_ADDRESSOF((
        ImpUtil::get<t_TYPE, BSLSTL_VARIANT_INDEX_OF(t_TYPE, Variant)>(*ptr)));
}
 
template <class t_TYPE, class t_HEAD, class... t_TAIL>
typename add_pointer<const t_TYPE>::type get_if(
                   const variant<t_HEAD, t_TAIL...> *ptr) BSLS_KEYWORD_NOEXCEPT
{
    BSLMF_ASSERT((BloombergLP::bslstl::Variant_HasUniqueType<
                  t_TYPE,
                  variant<t_HEAD, t_TAIL...> >::value));
 
    typedef typename bsl::variant<t_HEAD, t_TAIL...> Variant;
    typedef BloombergLP::bslstl::Variant_ImpUtil     ImpUtil;
 
    if (ptr == 0 || ptr->index() != BSLSTL_VARIANT_INDEX_OF(t_TYPE, Variant)) {
        return NULL;                                                  // RETURN
    }
    return BSLS_UTIL_ADDRESSOF(
         (ImpUtil::get<const t_TYPE, BSLSTL_VARIANT_INDEX_OF(t_TYPE, Variant)>(
             *ptr)));
}
#else
// {{{ BEGIN GENERATED CODE
// The generated code below is a workaround for the absence of perfect
// forwarding in some compilers.
template <size_t t_INDEX, class t_VARIANT>
typename Variant_GetIndexReturnType<t_INDEX, t_VARIANT>::pointer
get_if(t_VARIANT *ptr) BSLS_KEYWORD_NOEXCEPT
{
    BSLMF_ASSERT((t_INDEX < variant_size<t_VARIANT>::value));
 
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
    typedef typename bsl::variant_alternative<t_INDEX, t_VARIANT>::type Ret;
 
    if (ptr == 0 || ptr->index() != t_INDEX) {
        return NULL;
    }
 
    return BSLS_UTIL_ADDRESSOF((ImpUtil::get<Ret, t_INDEX>(*ptr)));
}
 
template <class t_TYPE, class t_VARIANT>
typename Variant_GetTypeReturnType<t_TYPE, t_VARIANT>::pointer
get_if(t_VARIANT *ptr) BSLS_KEYWORD_NOEXCEPT
{
    BSLMF_ASSERT((
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, t_VARIANT>::value));
 
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (ptr == 0 ||
        ptr->index() != BSLSTL_VARIANT_INDEX_OF(t_TYPE, t_VARIANT)) {
        return NULL;
    }
    return BSLS_UTIL_ADDRESSOF(
             (ImpUtil::get<t_TYPE, BSLSTL_VARIANT_INDEX_OF(t_TYPE, t_VARIANT)>(
                 *ptr)));
}
 
template <class t_TYPE, class t_VARIANT>
typename Variant_GetTypeReturnType<const t_TYPE, t_VARIANT>::pointer
get_if(const t_VARIANT *ptr) BSLS_KEYWORD_NOEXCEPT
{
    BSLMF_ASSERT((
        BloombergLP::bslstl::Variant_HasUniqueType<t_TYPE, t_VARIANT>::value));
 
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (ptr == 0 ||
        ptr->index() != BSLSTL_VARIANT_INDEX_OF(t_TYPE, t_VARIANT)) {
        return NULL;
    }
    return BSLS_UTIL_ADDRESSOF((
        ImpUtil::get<const t_TYPE, BSLSTL_VARIANT_INDEX_OF(t_TYPE, t_VARIANT)>(
            *ptr)));
}
// }}} END GENERATED CODE
#endif  // BSL_VARIANT_FULL_IMPLEMENTATION
 
#if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
// {{{ BEGIN GENERATED CODE
// Command line: sim_cpp11_features.pl bslstl_variant.h
#ifndef BSLSTL_VARIANT_VARIADIC_LIMIT
#define BSLSTL_VARIANT_VARIADIC_LIMIT 18
#endif
#ifndef BSLSTL_VARIANT_VARIADIC_LIMIT_U
#define BSLSTL_VARIANT_VARIADIC_LIMIT_U BSLSTL_VARIANT_VARIADIC_LIMIT
#endif
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 0
template <class t_HASHALG, class t_HEAD>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD>& input)
{
    if (!input.valueless_by_exception()) {
        hashAppend(hashAlg, input.index());
        BloombergLP::bslstl::Variant_HashVisitor<t_HASHALG> hashVisitor(
                                                                      hashAlg);
        visit(hashVisitor, input);
    }
    else {
        hashAppend(hashAlg, false);
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 1
template <class t_HASHALG, class t_HEAD, class t_TAIL_01>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD, t_TAIL_01>& input)
{
    if (!input.valueless_by_exception()) {
        hashAppend(hashAlg, input.index());
        BloombergLP::bslstl::Variant_HashVisitor<t_HASHALG> hashVisitor(
                                                                      hashAlg);
        visit(hashVisitor, input);
    }
    else {
        hashAppend(hashAlg, false);
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 2
template <class t_HASHALG, class t_HEAD, class t_TAIL_01,
                                         class t_TAIL_02>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02>& input)
{
    if (!input.valueless_by_exception()) {
        hashAppend(hashAlg, input.index());
        BloombergLP::bslstl::Variant_HashVisitor<t_HASHALG> hashVisitor(
                                                                      hashAlg);
        visit(hashVisitor, input);
    }
    else {
        hashAppend(hashAlg, false);
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 3
template <class t_HASHALG, class t_HEAD, class t_TAIL_01,
                                         class t_TAIL_02,
                                         class t_TAIL_03>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03>& input)
{
    if (!input.valueless_by_exception()) {
        hashAppend(hashAlg, input.index());
        BloombergLP::bslstl::Variant_HashVisitor<t_HASHALG> hashVisitor(
                                                                      hashAlg);
        visit(hashVisitor, input);
    }
    else {
        hashAppend(hashAlg, false);
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 4
template <class t_HASHALG, class t_HEAD, class t_TAIL_01,
                                         class t_TAIL_02,
                                         class t_TAIL_03,
                                         class t_TAIL_04>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04>& input)
{
    if (!input.valueless_by_exception()) {
        hashAppend(hashAlg, input.index());
        BloombergLP::bslstl::Variant_HashVisitor<t_HASHALG> hashVisitor(
                                                                      hashAlg);
        visit(hashVisitor, input);
    }
    else {
        hashAppend(hashAlg, false);
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 5
template <class t_HASHALG, class t_HEAD, class t_TAIL_01,
                                         class t_TAIL_02,
                                         class t_TAIL_03,
                                         class t_TAIL_04,
                                         class t_TAIL_05>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05>& input)
{
    if (!input.valueless_by_exception()) {
        hashAppend(hashAlg, input.index());
        BloombergLP::bslstl::Variant_HashVisitor<t_HASHALG> hashVisitor(
                                                                      hashAlg);
        visit(hashVisitor, input);
    }
    else {
        hashAppend(hashAlg, false);
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 6
template <class t_HASHALG, class t_HEAD, class t_TAIL_01,
                                         class t_TAIL_02,
                                         class t_TAIL_03,
                                         class t_TAIL_04,
                                         class t_TAIL_05,
                                         class t_TAIL_06>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06>& input)
{
    if (!input.valueless_by_exception()) {
        hashAppend(hashAlg, input.index());
        BloombergLP::bslstl::Variant_HashVisitor<t_HASHALG> hashVisitor(
                                                                      hashAlg);
        visit(hashVisitor, input);
    }
    else {
        hashAppend(hashAlg, false);
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 7
template <class t_HASHALG, class t_HEAD, class t_TAIL_01,
                                         class t_TAIL_02,
                                         class t_TAIL_03,
                                         class t_TAIL_04,
                                         class t_TAIL_05,
                                         class t_TAIL_06,
                                         class t_TAIL_07>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07>& input)
{
    if (!input.valueless_by_exception()) {
        hashAppend(hashAlg, input.index());
        BloombergLP::bslstl::Variant_HashVisitor<t_HASHALG> hashVisitor(
                                                                      hashAlg);
        visit(hashVisitor, input);
    }
    else {
        hashAppend(hashAlg, false);
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 8
template <class t_HASHALG, class t_HEAD, class t_TAIL_01,
                                         class t_TAIL_02,
                                         class t_TAIL_03,
                                         class t_TAIL_04,
                                         class t_TAIL_05,
                                         class t_TAIL_06,
                                         class t_TAIL_07,
                                         class t_TAIL_08>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08>& input)
{
    if (!input.valueless_by_exception()) {
        hashAppend(hashAlg, input.index());
        BloombergLP::bslstl::Variant_HashVisitor<t_HASHALG> hashVisitor(
                                                                      hashAlg);
        visit(hashVisitor, input);
    }
    else {
        hashAppend(hashAlg, false);
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 9
template <class t_HASHALG, class t_HEAD, class t_TAIL_01,
                                         class t_TAIL_02,
                                         class t_TAIL_03,
                                         class t_TAIL_04,
                                         class t_TAIL_05,
                                         class t_TAIL_06,
                                         class t_TAIL_07,
                                         class t_TAIL_08,
                                         class t_TAIL_09>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09>& input)
{
    if (!input.valueless_by_exception()) {
        hashAppend(hashAlg, input.index());
        BloombergLP::bslstl::Variant_HashVisitor<t_HASHALG> hashVisitor(
                                                                      hashAlg);
        visit(hashVisitor, input);
    }
    else {
        hashAppend(hashAlg, false);
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 10
template <class t_HASHALG, class t_HEAD, class t_TAIL_01,
                                         class t_TAIL_02,
                                         class t_TAIL_03,
                                         class t_TAIL_04,
                                         class t_TAIL_05,
                                         class t_TAIL_06,
                                         class t_TAIL_07,
                                         class t_TAIL_08,
                                         class t_TAIL_09,
                                         class t_TAIL_10>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10>& input)
{
    if (!input.valueless_by_exception()) {
        hashAppend(hashAlg, input.index());
        BloombergLP::bslstl::Variant_HashVisitor<t_HASHALG> hashVisitor(
                                                                      hashAlg);
        visit(hashVisitor, input);
    }
    else {
        hashAppend(hashAlg, false);
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 11
template <class t_HASHALG, class t_HEAD, class t_TAIL_01,
                                         class t_TAIL_02,
                                         class t_TAIL_03,
                                         class t_TAIL_04,
                                         class t_TAIL_05,
                                         class t_TAIL_06,
                                         class t_TAIL_07,
                                         class t_TAIL_08,
                                         class t_TAIL_09,
                                         class t_TAIL_10,
                                         class t_TAIL_11>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11>& input)
{
    if (!input.valueless_by_exception()) {
        hashAppend(hashAlg, input.index());
        BloombergLP::bslstl::Variant_HashVisitor<t_HASHALG> hashVisitor(
                                                                      hashAlg);
        visit(hashVisitor, input);
    }
    else {
        hashAppend(hashAlg, false);
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 12
template <class t_HASHALG, class t_HEAD, class t_TAIL_01,
                                         class t_TAIL_02,
                                         class t_TAIL_03,
                                         class t_TAIL_04,
                                         class t_TAIL_05,
                                         class t_TAIL_06,
                                         class t_TAIL_07,
                                         class t_TAIL_08,
                                         class t_TAIL_09,
                                         class t_TAIL_10,
                                         class t_TAIL_11,
                                         class t_TAIL_12>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12>& input)
{
    if (!input.valueless_by_exception()) {
        hashAppend(hashAlg, input.index());
        BloombergLP::bslstl::Variant_HashVisitor<t_HASHALG> hashVisitor(
                                                                      hashAlg);
        visit(hashVisitor, input);
    }
    else {
        hashAppend(hashAlg, false);
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 13
template <class t_HASHALG, class t_HEAD, class t_TAIL_01,
                                         class t_TAIL_02,
                                         class t_TAIL_03,
                                         class t_TAIL_04,
                                         class t_TAIL_05,
                                         class t_TAIL_06,
                                         class t_TAIL_07,
                                         class t_TAIL_08,
                                         class t_TAIL_09,
                                         class t_TAIL_10,
                                         class t_TAIL_11,
                                         class t_TAIL_12,
                                         class t_TAIL_13>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13>& input)
{
    if (!input.valueless_by_exception()) {
        hashAppend(hashAlg, input.index());
        BloombergLP::bslstl::Variant_HashVisitor<t_HASHALG> hashVisitor(
                                                                      hashAlg);
        visit(hashVisitor, input);
    }
    else {
        hashAppend(hashAlg, false);
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 14
template <class t_HASHALG, class t_HEAD, class t_TAIL_01,
                                         class t_TAIL_02,
                                         class t_TAIL_03,
                                         class t_TAIL_04,
                                         class t_TAIL_05,
                                         class t_TAIL_06,
                                         class t_TAIL_07,
                                         class t_TAIL_08,
                                         class t_TAIL_09,
                                         class t_TAIL_10,
                                         class t_TAIL_11,
                                         class t_TAIL_12,
                                         class t_TAIL_13,
                                         class t_TAIL_14>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14>& input)
{
    if (!input.valueless_by_exception()) {
        hashAppend(hashAlg, input.index());
        BloombergLP::bslstl::Variant_HashVisitor<t_HASHALG> hashVisitor(
                                                                      hashAlg);
        visit(hashVisitor, input);
    }
    else {
        hashAppend(hashAlg, false);
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 15
template <class t_HASHALG, class t_HEAD, class t_TAIL_01,
                                         class t_TAIL_02,
                                         class t_TAIL_03,
                                         class t_TAIL_04,
                                         class t_TAIL_05,
                                         class t_TAIL_06,
                                         class t_TAIL_07,
                                         class t_TAIL_08,
                                         class t_TAIL_09,
                                         class t_TAIL_10,
                                         class t_TAIL_11,
                                         class t_TAIL_12,
                                         class t_TAIL_13,
                                         class t_TAIL_14,
                                         class t_TAIL_15>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15>& input)
{
    if (!input.valueless_by_exception()) {
        hashAppend(hashAlg, input.index());
        BloombergLP::bslstl::Variant_HashVisitor<t_HASHALG> hashVisitor(
                                                                      hashAlg);
        visit(hashVisitor, input);
    }
    else {
        hashAppend(hashAlg, false);
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 16
template <class t_HASHALG, class t_HEAD, class t_TAIL_01,
                                         class t_TAIL_02,
                                         class t_TAIL_03,
                                         class t_TAIL_04,
                                         class t_TAIL_05,
                                         class t_TAIL_06,
                                         class t_TAIL_07,
                                         class t_TAIL_08,
                                         class t_TAIL_09,
                                         class t_TAIL_10,
                                         class t_TAIL_11,
                                         class t_TAIL_12,
                                         class t_TAIL_13,
                                         class t_TAIL_14,
                                         class t_TAIL_15,
                                         class t_TAIL_16>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16>& input)
{
    if (!input.valueless_by_exception()) {
        hashAppend(hashAlg, input.index());
        BloombergLP::bslstl::Variant_HashVisitor<t_HASHALG> hashVisitor(
                                                                      hashAlg);
        visit(hashVisitor, input);
    }
    else {
        hashAppend(hashAlg, false);
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 17
template <class t_HASHALG, class t_HEAD, class t_TAIL_01,
                                         class t_TAIL_02,
                                         class t_TAIL_03,
                                         class t_TAIL_04,
                                         class t_TAIL_05,
                                         class t_TAIL_06,
                                         class t_TAIL_07,
                                         class t_TAIL_08,
                                         class t_TAIL_09,
                                         class t_TAIL_10,
                                         class t_TAIL_11,
                                         class t_TAIL_12,
                                         class t_TAIL_13,
                                         class t_TAIL_14,
                                         class t_TAIL_15,
                                         class t_TAIL_16,
                                         class t_TAIL_17>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17>& input)
{
    if (!input.valueless_by_exception()) {
        hashAppend(hashAlg, input.index());
        BloombergLP::bslstl::Variant_HashVisitor<t_HASHALG> hashVisitor(
                                                                      hashAlg);
        visit(hashVisitor, input);
    }
    else {
        hashAppend(hashAlg, false);
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 18
template <class t_HASHALG, class t_HEAD, class t_TAIL_01,
                                         class t_TAIL_02,
                                         class t_TAIL_03,
                                         class t_TAIL_04,
                                         class t_TAIL_05,
                                         class t_TAIL_06,
                                         class t_TAIL_07,
                                         class t_TAIL_08,
                                         class t_TAIL_09,
                                         class t_TAIL_10,
                                         class t_TAIL_11,
                                         class t_TAIL_12,
                                         class t_TAIL_13,
                                         class t_TAIL_14,
                                         class t_TAIL_15,
                                         class t_TAIL_16,
                                         class t_TAIL_17,
                                         class t_TAIL_18>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD, t_TAIL_01,
                                                          t_TAIL_02,
                                                          t_TAIL_03,
                                                          t_TAIL_04,
                                                          t_TAIL_05,
                                                          t_TAIL_06,
                                                          t_TAIL_07,
                                                          t_TAIL_08,
                                                          t_TAIL_09,
                                                          t_TAIL_10,
                                                          t_TAIL_11,
                                                          t_TAIL_12,
                                                          t_TAIL_13,
                                                          t_TAIL_14,
                                                          t_TAIL_15,
                                                          t_TAIL_16,
                                                          t_TAIL_17,
                                                          t_TAIL_18>& input)
{
    if (!input.valueless_by_exception()) {
        hashAppend(hashAlg, input.index());
        BloombergLP::bslstl::Variant_HashVisitor<t_HASHALG> hashVisitor(
                                                                      hashAlg);
        visit(hashVisitor, input);
    }
    else {
        hashAppend(hashAlg, false);
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 0
template <class t_TYPE, class t_HEAD>
bool holds_alternative(
                   const variant<t_HEAD>& obj) BSLS_KEYWORD_NOEXCEPT
{
    BSLMF_ASSERT((BloombergLP::bslstl::Variant_HasUniqueType<
                  t_TYPE,
                  variant<t_HEAD> >::value));
    typedef typename bsl::variant<t_HEAD> Variant;
    return obj.index() == BSLSTL_VARIANT_INDEX_OF(t_TYPE, Variant);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 1
template <class t_TYPE, class t_HEAD, class t_TAIL_01>
bool holds_alternative(
                   const variant<t_HEAD, t_TAIL_01>& obj) BSLS_KEYWORD_NOEXCEPT
{
    BSLMF_ASSERT((BloombergLP::bslstl::Variant_HasUniqueType<
                  t_TYPE,
                  variant<t_HEAD, t_TAIL_01> >::value));
    typedef typename bsl::variant<t_HEAD, t_TAIL_01> Variant;
    return obj.index() == BSLSTL_VARIANT_INDEX_OF(t_TYPE, Variant);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 2
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02>
bool holds_alternative(
                   const variant<t_HEAD, t_TAIL_01,
                                         t_TAIL_02>& obj) BSLS_KEYWORD_NOEXCEPT
{
    BSLMF_ASSERT((BloombergLP::bslstl::Variant_HasUniqueType<
                  t_TYPE,
                  variant<t_HEAD, t_TAIL_01,
                                  t_TAIL_02> >::value));
    typedef typename bsl::variant<t_HEAD, t_TAIL_01,
                                          t_TAIL_02> Variant;
    return obj.index() == BSLSTL_VARIANT_INDEX_OF(t_TYPE, Variant);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 3
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03>
bool holds_alternative(
                   const variant<t_HEAD, t_TAIL_01,
                                         t_TAIL_02,
                                         t_TAIL_03>& obj) BSLS_KEYWORD_NOEXCEPT
{
    BSLMF_ASSERT((BloombergLP::bslstl::Variant_HasUniqueType<
                  t_TYPE,
                  variant<t_HEAD, t_TAIL_01,
                                  t_TAIL_02,
                                  t_TAIL_03> >::value));
    typedef typename bsl::variant<t_HEAD, t_TAIL_01,
                                          t_TAIL_02,
                                          t_TAIL_03> Variant;
    return obj.index() == BSLSTL_VARIANT_INDEX_OF(t_TYPE, Variant);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 4
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04>
bool holds_alternative(
                   const variant<t_HEAD, t_TAIL_01,
                                         t_TAIL_02,
                                         t_TAIL_03,
                                         t_TAIL_04>& obj) BSLS_KEYWORD_NOEXCEPT
{
    BSLMF_ASSERT((BloombergLP::bslstl::Variant_HasUniqueType<
                  t_TYPE,
                  variant<t_HEAD, t_TAIL_01,
                                  t_TAIL_02,
                                  t_TAIL_03,
                                  t_TAIL_04> >::value));
    typedef typename bsl::variant<t_HEAD, t_TAIL_01,
                                          t_TAIL_02,
                                          t_TAIL_03,
                                          t_TAIL_04> Variant;
    return obj.index() == BSLSTL_VARIANT_INDEX_OF(t_TYPE, Variant);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 5
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05>
bool holds_alternative(
                   const variant<t_HEAD, t_TAIL_01,
                                         t_TAIL_02,
                                         t_TAIL_03,
                                         t_TAIL_04,
                                         t_TAIL_05>& obj) BSLS_KEYWORD_NOEXCEPT
{
    BSLMF_ASSERT((BloombergLP::bslstl::Variant_HasUniqueType<
                  t_TYPE,
                  variant<t_HEAD, t_TAIL_01,
                                  t_TAIL_02,
                                  t_TAIL_03,
                                  t_TAIL_04,
                                  t_TAIL_05> >::value));
    typedef typename bsl::variant<t_HEAD, t_TAIL_01,
                                          t_TAIL_02,
                                          t_TAIL_03,
                                          t_TAIL_04,
                                          t_TAIL_05> Variant;
    return obj.index() == BSLSTL_VARIANT_INDEX_OF(t_TYPE, Variant);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 6
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06>
bool holds_alternative(
                   const variant<t_HEAD, t_TAIL_01,
                                         t_TAIL_02,
                                         t_TAIL_03,
                                         t_TAIL_04,
                                         t_TAIL_05,
                                         t_TAIL_06>& obj) BSLS_KEYWORD_NOEXCEPT
{
    BSLMF_ASSERT((BloombergLP::bslstl::Variant_HasUniqueType<
                  t_TYPE,
                  variant<t_HEAD, t_TAIL_01,
                                  t_TAIL_02,
                                  t_TAIL_03,
                                  t_TAIL_04,
                                  t_TAIL_05,
                                  t_TAIL_06> >::value));
    typedef typename bsl::variant<t_HEAD, t_TAIL_01,
                                          t_TAIL_02,
                                          t_TAIL_03,
                                          t_TAIL_04,
                                          t_TAIL_05,
                                          t_TAIL_06> Variant;
    return obj.index() == BSLSTL_VARIANT_INDEX_OF(t_TYPE, Variant);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 7
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07>
bool holds_alternative(
                   const variant<t_HEAD, t_TAIL_01,
                                         t_TAIL_02,
                                         t_TAIL_03,
                                         t_TAIL_04,
                                         t_TAIL_05,
                                         t_TAIL_06,
                                         t_TAIL_07>& obj) BSLS_KEYWORD_NOEXCEPT
{
    BSLMF_ASSERT((BloombergLP::bslstl::Variant_HasUniqueType<
                  t_TYPE,
                  variant<t_HEAD, t_TAIL_01,
                                  t_TAIL_02,
                                  t_TAIL_03,
                                  t_TAIL_04,
                                  t_TAIL_05,
                                  t_TAIL_06,
                                  t_TAIL_07> >::value));
    typedef typename bsl::variant<t_HEAD, t_TAIL_01,
                                          t_TAIL_02,
                                          t_TAIL_03,
                                          t_TAIL_04,
                                          t_TAIL_05,
                                          t_TAIL_06,
                                          t_TAIL_07> Variant;
    return obj.index() == BSLSTL_VARIANT_INDEX_OF(t_TYPE, Variant);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 8
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08>
bool holds_alternative(
                   const variant<t_HEAD, t_TAIL_01,
                                         t_TAIL_02,
                                         t_TAIL_03,
                                         t_TAIL_04,
                                         t_TAIL_05,
                                         t_TAIL_06,
                                         t_TAIL_07,
                                         t_TAIL_08>& obj) BSLS_KEYWORD_NOEXCEPT
{
    BSLMF_ASSERT((BloombergLP::bslstl::Variant_HasUniqueType<
                  t_TYPE,
                  variant<t_HEAD, t_TAIL_01,
                                  t_TAIL_02,
                                  t_TAIL_03,
                                  t_TAIL_04,
                                  t_TAIL_05,
                                  t_TAIL_06,
                                  t_TAIL_07,
                                  t_TAIL_08> >::value));
    typedef typename bsl::variant<t_HEAD, t_TAIL_01,
                                          t_TAIL_02,
                                          t_TAIL_03,
                                          t_TAIL_04,
                                          t_TAIL_05,
                                          t_TAIL_06,
                                          t_TAIL_07,
                                          t_TAIL_08> Variant;
    return obj.index() == BSLSTL_VARIANT_INDEX_OF(t_TYPE, Variant);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 9
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09>
bool holds_alternative(
                   const variant<t_HEAD, t_TAIL_01,
                                         t_TAIL_02,
                                         t_TAIL_03,
                                         t_TAIL_04,
                                         t_TAIL_05,
                                         t_TAIL_06,
                                         t_TAIL_07,
                                         t_TAIL_08,
                                         t_TAIL_09>& obj) BSLS_KEYWORD_NOEXCEPT
{
    BSLMF_ASSERT((BloombergLP::bslstl::Variant_HasUniqueType<
                  t_TYPE,
                  variant<t_HEAD, t_TAIL_01,
                                  t_TAIL_02,
                                  t_TAIL_03,
                                  t_TAIL_04,
                                  t_TAIL_05,
                                  t_TAIL_06,
                                  t_TAIL_07,
                                  t_TAIL_08,
                                  t_TAIL_09> >::value));
    typedef typename bsl::variant<t_HEAD, t_TAIL_01,
                                          t_TAIL_02,
                                          t_TAIL_03,
                                          t_TAIL_04,
                                          t_TAIL_05,
                                          t_TAIL_06,
                                          t_TAIL_07,
                                          t_TAIL_08,
                                          t_TAIL_09> Variant;
    return obj.index() == BSLSTL_VARIANT_INDEX_OF(t_TYPE, Variant);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 10
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10>
bool holds_alternative(
                   const variant<t_HEAD, t_TAIL_01,
                                         t_TAIL_02,
                                         t_TAIL_03,
                                         t_TAIL_04,
                                         t_TAIL_05,
                                         t_TAIL_06,
                                         t_TAIL_07,
                                         t_TAIL_08,
                                         t_TAIL_09,
                                         t_TAIL_10>& obj) BSLS_KEYWORD_NOEXCEPT
{
    BSLMF_ASSERT((BloombergLP::bslstl::Variant_HasUniqueType<
                  t_TYPE,
                  variant<t_HEAD, t_TAIL_01,
                                  t_TAIL_02,
                                  t_TAIL_03,
                                  t_TAIL_04,
                                  t_TAIL_05,
                                  t_TAIL_06,
                                  t_TAIL_07,
                                  t_TAIL_08,
                                  t_TAIL_09,
                                  t_TAIL_10> >::value));
    typedef typename bsl::variant<t_HEAD, t_TAIL_01,
                                          t_TAIL_02,
                                          t_TAIL_03,
                                          t_TAIL_04,
                                          t_TAIL_05,
                                          t_TAIL_06,
                                          t_TAIL_07,
                                          t_TAIL_08,
                                          t_TAIL_09,
                                          t_TAIL_10> Variant;
    return obj.index() == BSLSTL_VARIANT_INDEX_OF(t_TYPE, Variant);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 11
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11>
bool holds_alternative(
                   const variant<t_HEAD, t_TAIL_01,
                                         t_TAIL_02,
                                         t_TAIL_03,
                                         t_TAIL_04,
                                         t_TAIL_05,
                                         t_TAIL_06,
                                         t_TAIL_07,
                                         t_TAIL_08,
                                         t_TAIL_09,
                                         t_TAIL_10,
                                         t_TAIL_11>& obj) BSLS_KEYWORD_NOEXCEPT
{
    BSLMF_ASSERT((BloombergLP::bslstl::Variant_HasUniqueType<
                  t_TYPE,
                  variant<t_HEAD, t_TAIL_01,
                                  t_TAIL_02,
                                  t_TAIL_03,
                                  t_TAIL_04,
                                  t_TAIL_05,
                                  t_TAIL_06,
                                  t_TAIL_07,
                                  t_TAIL_08,
                                  t_TAIL_09,
                                  t_TAIL_10,
                                  t_TAIL_11> >::value));
    typedef typename bsl::variant<t_HEAD, t_TAIL_01,
                                          t_TAIL_02,
                                          t_TAIL_03,
                                          t_TAIL_04,
                                          t_TAIL_05,
                                          t_TAIL_06,
                                          t_TAIL_07,
                                          t_TAIL_08,
                                          t_TAIL_09,
                                          t_TAIL_10,
                                          t_TAIL_11> Variant;
    return obj.index() == BSLSTL_VARIANT_INDEX_OF(t_TYPE, Variant);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 12
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12>
bool holds_alternative(
                   const variant<t_HEAD, t_TAIL_01,
                                         t_TAIL_02,
                                         t_TAIL_03,
                                         t_TAIL_04,
                                         t_TAIL_05,
                                         t_TAIL_06,
                                         t_TAIL_07,
                                         t_TAIL_08,
                                         t_TAIL_09,
                                         t_TAIL_10,
                                         t_TAIL_11,
                                         t_TAIL_12>& obj) BSLS_KEYWORD_NOEXCEPT
{
    BSLMF_ASSERT((BloombergLP::bslstl::Variant_HasUniqueType<
                  t_TYPE,
                  variant<t_HEAD, t_TAIL_01,
                                  t_TAIL_02,
                                  t_TAIL_03,
                                  t_TAIL_04,
                                  t_TAIL_05,
                                  t_TAIL_06,
                                  t_TAIL_07,
                                  t_TAIL_08,
                                  t_TAIL_09,
                                  t_TAIL_10,
                                  t_TAIL_11,
                                  t_TAIL_12> >::value));
    typedef typename bsl::variant<t_HEAD, t_TAIL_01,
                                          t_TAIL_02,
                                          t_TAIL_03,
                                          t_TAIL_04,
                                          t_TAIL_05,
                                          t_TAIL_06,
                                          t_TAIL_07,
                                          t_TAIL_08,
                                          t_TAIL_09,
                                          t_TAIL_10,
                                          t_TAIL_11,
                                          t_TAIL_12> Variant;
    return obj.index() == BSLSTL_VARIANT_INDEX_OF(t_TYPE, Variant);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 13
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13>
bool holds_alternative(
                   const variant<t_HEAD, t_TAIL_01,
                                         t_TAIL_02,
                                         t_TAIL_03,
                                         t_TAIL_04,
                                         t_TAIL_05,
                                         t_TAIL_06,
                                         t_TAIL_07,
                                         t_TAIL_08,
                                         t_TAIL_09,
                                         t_TAIL_10,
                                         t_TAIL_11,
                                         t_TAIL_12,
                                         t_TAIL_13>& obj) BSLS_KEYWORD_NOEXCEPT
{
    BSLMF_ASSERT((BloombergLP::bslstl::Variant_HasUniqueType<
                  t_TYPE,
                  variant<t_HEAD, t_TAIL_01,
                                  t_TAIL_02,
                                  t_TAIL_03,
                                  t_TAIL_04,
                                  t_TAIL_05,
                                  t_TAIL_06,
                                  t_TAIL_07,
                                  t_TAIL_08,
                                  t_TAIL_09,
                                  t_TAIL_10,
                                  t_TAIL_11,
                                  t_TAIL_12,
                                  t_TAIL_13> >::value));
    typedef typename bsl::variant<t_HEAD, t_TAIL_01,
                                          t_TAIL_02,
                                          t_TAIL_03,
                                          t_TAIL_04,
                                          t_TAIL_05,
                                          t_TAIL_06,
                                          t_TAIL_07,
                                          t_TAIL_08,
                                          t_TAIL_09,
                                          t_TAIL_10,
                                          t_TAIL_11,
                                          t_TAIL_12,
                                          t_TAIL_13> Variant;
    return obj.index() == BSLSTL_VARIANT_INDEX_OF(t_TYPE, Variant);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 14
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14>
bool holds_alternative(
                   const variant<t_HEAD, t_TAIL_01,
                                         t_TAIL_02,
                                         t_TAIL_03,
                                         t_TAIL_04,
                                         t_TAIL_05,
                                         t_TAIL_06,
                                         t_TAIL_07,
                                         t_TAIL_08,
                                         t_TAIL_09,
                                         t_TAIL_10,
                                         t_TAIL_11,
                                         t_TAIL_12,
                                         t_TAIL_13,
                                         t_TAIL_14>& obj) BSLS_KEYWORD_NOEXCEPT
{
    BSLMF_ASSERT((BloombergLP::bslstl::Variant_HasUniqueType<
                  t_TYPE,
                  variant<t_HEAD, t_TAIL_01,
                                  t_TAIL_02,
                                  t_TAIL_03,
                                  t_TAIL_04,
                                  t_TAIL_05,
                                  t_TAIL_06,
                                  t_TAIL_07,
                                  t_TAIL_08,
                                  t_TAIL_09,
                                  t_TAIL_10,
                                  t_TAIL_11,
                                  t_TAIL_12,
                                  t_TAIL_13,
                                  t_TAIL_14> >::value));
    typedef typename bsl::variant<t_HEAD, t_TAIL_01,
                                          t_TAIL_02,
                                          t_TAIL_03,
                                          t_TAIL_04,
                                          t_TAIL_05,
                                          t_TAIL_06,
                                          t_TAIL_07,
                                          t_TAIL_08,
                                          t_TAIL_09,
                                          t_TAIL_10,
                                          t_TAIL_11,
                                          t_TAIL_12,
                                          t_TAIL_13,
                                          t_TAIL_14> Variant;
    return obj.index() == BSLSTL_VARIANT_INDEX_OF(t_TYPE, Variant);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 15
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14,
                                      class t_TAIL_15>
bool holds_alternative(
                   const variant<t_HEAD, t_TAIL_01,
                                         t_TAIL_02,
                                         t_TAIL_03,
                                         t_TAIL_04,
                                         t_TAIL_05,
                                         t_TAIL_06,
                                         t_TAIL_07,
                                         t_TAIL_08,
                                         t_TAIL_09,
                                         t_TAIL_10,
                                         t_TAIL_11,
                                         t_TAIL_12,
                                         t_TAIL_13,
                                         t_TAIL_14,
                                         t_TAIL_15>& obj) BSLS_KEYWORD_NOEXCEPT
{
    BSLMF_ASSERT((BloombergLP::bslstl::Variant_HasUniqueType<
                  t_TYPE,
                  variant<t_HEAD, t_TAIL_01,
                                  t_TAIL_02,
                                  t_TAIL_03,
                                  t_TAIL_04,
                                  t_TAIL_05,
                                  t_TAIL_06,
                                  t_TAIL_07,
                                  t_TAIL_08,
                                  t_TAIL_09,
                                  t_TAIL_10,
                                  t_TAIL_11,
                                  t_TAIL_12,
                                  t_TAIL_13,
                                  t_TAIL_14,
                                  t_TAIL_15> >::value));
    typedef typename bsl::variant<t_HEAD, t_TAIL_01,
                                          t_TAIL_02,
                                          t_TAIL_03,
                                          t_TAIL_04,
                                          t_TAIL_05,
                                          t_TAIL_06,
                                          t_TAIL_07,
                                          t_TAIL_08,
                                          t_TAIL_09,
                                          t_TAIL_10,
                                          t_TAIL_11,
                                          t_TAIL_12,
                                          t_TAIL_13,
                                          t_TAIL_14,
                                          t_TAIL_15> Variant;
    return obj.index() == BSLSTL_VARIANT_INDEX_OF(t_TYPE, Variant);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 16
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14,
                                      class t_TAIL_15,
                                      class t_TAIL_16>
bool holds_alternative(
                   const variant<t_HEAD, t_TAIL_01,
                                         t_TAIL_02,
                                         t_TAIL_03,
                                         t_TAIL_04,
                                         t_TAIL_05,
                                         t_TAIL_06,
                                         t_TAIL_07,
                                         t_TAIL_08,
                                         t_TAIL_09,
                                         t_TAIL_10,
                                         t_TAIL_11,
                                         t_TAIL_12,
                                         t_TAIL_13,
                                         t_TAIL_14,
                                         t_TAIL_15,
                                         t_TAIL_16>& obj) BSLS_KEYWORD_NOEXCEPT
{
    BSLMF_ASSERT((BloombergLP::bslstl::Variant_HasUniqueType<
                  t_TYPE,
                  variant<t_HEAD, t_TAIL_01,
                                  t_TAIL_02,
                                  t_TAIL_03,
                                  t_TAIL_04,
                                  t_TAIL_05,
                                  t_TAIL_06,
                                  t_TAIL_07,
                                  t_TAIL_08,
                                  t_TAIL_09,
                                  t_TAIL_10,
                                  t_TAIL_11,
                                  t_TAIL_12,
                                  t_TAIL_13,
                                  t_TAIL_14,
                                  t_TAIL_15,
                                  t_TAIL_16> >::value));
    typedef typename bsl::variant<t_HEAD, t_TAIL_01,
                                          t_TAIL_02,
                                          t_TAIL_03,
                                          t_TAIL_04,
                                          t_TAIL_05,
                                          t_TAIL_06,
                                          t_TAIL_07,
                                          t_TAIL_08,
                                          t_TAIL_09,
                                          t_TAIL_10,
                                          t_TAIL_11,
                                          t_TAIL_12,
                                          t_TAIL_13,
                                          t_TAIL_14,
                                          t_TAIL_15,
                                          t_TAIL_16> Variant;
    return obj.index() == BSLSTL_VARIANT_INDEX_OF(t_TYPE, Variant);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 17
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14,
                                      class t_TAIL_15,
                                      class t_TAIL_16,
                                      class t_TAIL_17>
bool holds_alternative(
                   const variant<t_HEAD, t_TAIL_01,
                                         t_TAIL_02,
                                         t_TAIL_03,
                                         t_TAIL_04,
                                         t_TAIL_05,
                                         t_TAIL_06,
                                         t_TAIL_07,
                                         t_TAIL_08,
                                         t_TAIL_09,
                                         t_TAIL_10,
                                         t_TAIL_11,
                                         t_TAIL_12,
                                         t_TAIL_13,
                                         t_TAIL_14,
                                         t_TAIL_15,
                                         t_TAIL_16,
                                         t_TAIL_17>& obj) BSLS_KEYWORD_NOEXCEPT
{
    BSLMF_ASSERT((BloombergLP::bslstl::Variant_HasUniqueType<
                  t_TYPE,
                  variant<t_HEAD, t_TAIL_01,
                                  t_TAIL_02,
                                  t_TAIL_03,
                                  t_TAIL_04,
                                  t_TAIL_05,
                                  t_TAIL_06,
                                  t_TAIL_07,
                                  t_TAIL_08,
                                  t_TAIL_09,
                                  t_TAIL_10,
                                  t_TAIL_11,
                                  t_TAIL_12,
                                  t_TAIL_13,
                                  t_TAIL_14,
                                  t_TAIL_15,
                                  t_TAIL_16,
                                  t_TAIL_17> >::value));
    typedef typename bsl::variant<t_HEAD, t_TAIL_01,
                                          t_TAIL_02,
                                          t_TAIL_03,
                                          t_TAIL_04,
                                          t_TAIL_05,
                                          t_TAIL_06,
                                          t_TAIL_07,
                                          t_TAIL_08,
                                          t_TAIL_09,
                                          t_TAIL_10,
                                          t_TAIL_11,
                                          t_TAIL_12,
                                          t_TAIL_13,
                                          t_TAIL_14,
                                          t_TAIL_15,
                                          t_TAIL_16,
                                          t_TAIL_17> Variant;
    return obj.index() == BSLSTL_VARIANT_INDEX_OF(t_TYPE, Variant);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 18
template <class t_TYPE, class t_HEAD, class t_TAIL_01,
                                      class t_TAIL_02,
                                      class t_TAIL_03,
                                      class t_TAIL_04,
                                      class t_TAIL_05,
                                      class t_TAIL_06,
                                      class t_TAIL_07,
                                      class t_TAIL_08,
                                      class t_TAIL_09,
                                      class t_TAIL_10,
                                      class t_TAIL_11,
                                      class t_TAIL_12,
                                      class t_TAIL_13,
                                      class t_TAIL_14,
                                      class t_TAIL_15,
                                      class t_TAIL_16,
                                      class t_TAIL_17,
                                      class t_TAIL_18>
bool holds_alternative(
                   const variant<t_HEAD, t_TAIL_01,
                                         t_TAIL_02,
                                         t_TAIL_03,
                                         t_TAIL_04,
                                         t_TAIL_05,
                                         t_TAIL_06,
                                         t_TAIL_07,
                                         t_TAIL_08,
                                         t_TAIL_09,
                                         t_TAIL_10,
                                         t_TAIL_11,
                                         t_TAIL_12,
                                         t_TAIL_13,
                                         t_TAIL_14,
                                         t_TAIL_15,
                                         t_TAIL_16,
                                         t_TAIL_17,
                                         t_TAIL_18>& obj) BSLS_KEYWORD_NOEXCEPT
{
    BSLMF_ASSERT((BloombergLP::bslstl::Variant_HasUniqueType<
                  t_TYPE,
                  variant<t_HEAD, t_TAIL_01,
                                  t_TAIL_02,
                                  t_TAIL_03,
                                  t_TAIL_04,
                                  t_TAIL_05,
                                  t_TAIL_06,
                                  t_TAIL_07,
                                  t_TAIL_08,
                                  t_TAIL_09,
                                  t_TAIL_10,
                                  t_TAIL_11,
                                  t_TAIL_12,
                                  t_TAIL_13,
                                  t_TAIL_14,
                                  t_TAIL_15,
                                  t_TAIL_16,
                                  t_TAIL_17,
                                  t_TAIL_18> >::value));
    typedef typename bsl::variant<t_HEAD, t_TAIL_01,
                                          t_TAIL_02,
                                          t_TAIL_03,
                                          t_TAIL_04,
                                          t_TAIL_05,
                                          t_TAIL_06,
                                          t_TAIL_07,
                                          t_TAIL_08,
                                          t_TAIL_09,
                                          t_TAIL_10,
                                          t_TAIL_11,
                                          t_TAIL_12,
                                          t_TAIL_13,
                                          t_TAIL_14,
                                          t_TAIL_15,
                                          t_TAIL_16,
                                          t_TAIL_17,
                                          t_TAIL_18> Variant;
    return obj.index() == BSLSTL_VARIANT_INDEX_OF(t_TYPE, Variant);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 0
template <class t_HEAD>
void swap(bsl::variant<t_HEAD>& lhs,
          bsl::variant<t_HEAD>& rhs)
{
    BloombergLP::bslstl::variant_swapImpl(
        bsl::integral_constant<
            bool,
            BloombergLP::bslstl::
                Variant_UsesBslmaAllocatorAny<t_HEAD>::value>(),
        lhs,
        rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 1
template <class t_HEAD, class t_TAIL_01>
void swap(bsl::variant<t_HEAD, t_TAIL_01>& lhs,
          bsl::variant<t_HEAD, t_TAIL_01>& rhs)
{
    BloombergLP::bslstl::variant_swapImpl(
        bsl::integral_constant<
            bool,
            BloombergLP::bslstl::
                Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01>::value>(),
        lhs,
        rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
void swap(bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02>& lhs,
          bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02>& rhs)
{
    BloombergLP::bslstl::variant_swapImpl(
        bsl::integral_constant<
            bool,
            BloombergLP::bslstl::
                Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02>::value>(),
        lhs,
        rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
void swap(bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03>& lhs,
          bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03>& rhs)
{
    BloombergLP::bslstl::variant_swapImpl(
        bsl::integral_constant<
            bool,
            BloombergLP::bslstl::
                Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03>::value>(),
        lhs,
        rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
void swap(bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04>& lhs,
          bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04>& rhs)
{
    BloombergLP::bslstl::variant_swapImpl(
        bsl::integral_constant<
            bool,
            BloombergLP::bslstl::
                Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04>::value>(),
        lhs,
        rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
void swap(bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05>& lhs,
          bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05>& rhs)
{
    BloombergLP::bslstl::variant_swapImpl(
        bsl::integral_constant<
            bool,
            BloombergLP::bslstl::
                Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05>::value>(),
        lhs,
        rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
void swap(bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06>& lhs,
          bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06>& rhs)
{
    BloombergLP::bslstl::variant_swapImpl(
        bsl::integral_constant<
            bool,
            BloombergLP::bslstl::
                Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06>::value>(),
        lhs,
        rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
void swap(bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07>& lhs,
          bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07>& rhs)
{
    BloombergLP::bslstl::variant_swapImpl(
        bsl::integral_constant<
            bool,
            BloombergLP::bslstl::
                Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07>::value>(),
        lhs,
        rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
void swap(bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08>& lhs,
          bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08>& rhs)
{
    BloombergLP::bslstl::variant_swapImpl(
        bsl::integral_constant<
            bool,
            BloombergLP::bslstl::
                Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08>::value>(),
        lhs,
        rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
void swap(bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09>& lhs,
          bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09>& rhs)
{
    BloombergLP::bslstl::variant_swapImpl(
        bsl::integral_constant<
            bool,
            BloombergLP::bslstl::
                Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09>::value>(),
        lhs,
        rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
void swap(bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09,
                               t_TAIL_10>& lhs,
          bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09,
                               t_TAIL_10>& rhs)
{
    BloombergLP::bslstl::variant_swapImpl(
        bsl::integral_constant<
            bool,
            BloombergLP::bslstl::
                Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10>::value>(),
        lhs,
        rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
void swap(bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09,
                               t_TAIL_10,
                               t_TAIL_11>& lhs,
          bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09,
                               t_TAIL_10,
                               t_TAIL_11>& rhs)
{
    BloombergLP::bslstl::variant_swapImpl(
        bsl::integral_constant<
            bool,
            BloombergLP::bslstl::
                Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11>::value>(),
        lhs,
        rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
void swap(bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09,
                               t_TAIL_10,
                               t_TAIL_11,
                               t_TAIL_12>& lhs,
          bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09,
                               t_TAIL_10,
                               t_TAIL_11,
                               t_TAIL_12>& rhs)
{
    BloombergLP::bslstl::variant_swapImpl(
        bsl::integral_constant<
            bool,
            BloombergLP::bslstl::
                Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12>::value>(),
        lhs,
        rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
void swap(bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09,
                               t_TAIL_10,
                               t_TAIL_11,
                               t_TAIL_12,
                               t_TAIL_13>& lhs,
          bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09,
                               t_TAIL_10,
                               t_TAIL_11,
                               t_TAIL_12,
                               t_TAIL_13>& rhs)
{
    BloombergLP::bslstl::variant_swapImpl(
        bsl::integral_constant<
            bool,
            BloombergLP::bslstl::
                Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13>::value>(),
        lhs,
        rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
void swap(bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09,
                               t_TAIL_10,
                               t_TAIL_11,
                               t_TAIL_12,
                               t_TAIL_13,
                               t_TAIL_14>& lhs,
          bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09,
                               t_TAIL_10,
                               t_TAIL_11,
                               t_TAIL_12,
                               t_TAIL_13,
                               t_TAIL_14>& rhs)
{
    BloombergLP::bslstl::variant_swapImpl(
        bsl::integral_constant<
            bool,
            BloombergLP::bslstl::
                Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14>::value>(),
        lhs,
        rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
void swap(bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09,
                               t_TAIL_10,
                               t_TAIL_11,
                               t_TAIL_12,
                               t_TAIL_13,
                               t_TAIL_14,
                               t_TAIL_15>& lhs,
          bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09,
                               t_TAIL_10,
                               t_TAIL_11,
                               t_TAIL_12,
                               t_TAIL_13,
                               t_TAIL_14,
                               t_TAIL_15>& rhs)
{
    BloombergLP::bslstl::variant_swapImpl(
        bsl::integral_constant<
            bool,
            BloombergLP::bslstl::
                Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15>::value>(),
        lhs,
        rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
void swap(bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09,
                               t_TAIL_10,
                               t_TAIL_11,
                               t_TAIL_12,
                               t_TAIL_13,
                               t_TAIL_14,
                               t_TAIL_15,
                               t_TAIL_16>& lhs,
          bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09,
                               t_TAIL_10,
                               t_TAIL_11,
                               t_TAIL_12,
                               t_TAIL_13,
                               t_TAIL_14,
                               t_TAIL_15,
                               t_TAIL_16>& rhs)
{
    BloombergLP::bslstl::variant_swapImpl(
        bsl::integral_constant<
            bool,
            BloombergLP::bslstl::
                Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16>::value>(),
        lhs,
        rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
void swap(bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09,
                               t_TAIL_10,
                               t_TAIL_11,
                               t_TAIL_12,
                               t_TAIL_13,
                               t_TAIL_14,
                               t_TAIL_15,
                               t_TAIL_16,
                               t_TAIL_17>& lhs,
          bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09,
                               t_TAIL_10,
                               t_TAIL_11,
                               t_TAIL_12,
                               t_TAIL_13,
                               t_TAIL_14,
                               t_TAIL_15,
                               t_TAIL_16,
                               t_TAIL_17>& rhs)
{
    BloombergLP::bslstl::variant_swapImpl(
        bsl::integral_constant<
            bool,
            BloombergLP::bslstl::
                Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16,
                                                      t_TAIL_17>::value>(),
        lhs,
        rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
void swap(bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09,
                               t_TAIL_10,
                               t_TAIL_11,
                               t_TAIL_12,
                               t_TAIL_13,
                               t_TAIL_14,
                               t_TAIL_15,
                               t_TAIL_16,
                               t_TAIL_17,
                               t_TAIL_18>& lhs,
          bsl::variant<t_HEAD, t_TAIL_01,
                               t_TAIL_02,
                               t_TAIL_03,
                               t_TAIL_04,
                               t_TAIL_05,
                               t_TAIL_06,
                               t_TAIL_07,
                               t_TAIL_08,
                               t_TAIL_09,
                               t_TAIL_10,
                               t_TAIL_11,
                               t_TAIL_12,
                               t_TAIL_13,
                               t_TAIL_14,
                               t_TAIL_15,
                               t_TAIL_16,
                               t_TAIL_17,
                               t_TAIL_18>& rhs)
{
    BloombergLP::bslstl::variant_swapImpl(
        bsl::integral_constant<
            bool,
            BloombergLP::bslstl::
                Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL_01,
                                                      t_TAIL_02,
                                                      t_TAIL_03,
                                                      t_TAIL_04,
                                                      t_TAIL_05,
                                                      t_TAIL_06,
                                                      t_TAIL_07,
                                                      t_TAIL_08,
                                                      t_TAIL_09,
                                                      t_TAIL_10,
                                                      t_TAIL_11,
                                                      t_TAIL_12,
                                                      t_TAIL_13,
                                                      t_TAIL_14,
                                                      t_TAIL_15,
                                                      t_TAIL_16,
                                                      t_TAIL_17,
                                                      t_TAIL_18>::value>(),
        lhs,
        rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 0
template <class t_HEAD>
bool operator==(const variant<t_HEAD>& lhs,
                const variant<t_HEAD>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    return ImpUtil::Equal(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 1
template <class t_HEAD, class t_TAIL_01>
bool operator==(const variant<t_HEAD, t_TAIL_01>& lhs,
                const variant<t_HEAD, t_TAIL_01>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    return ImpUtil::Equal(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
bool operator==(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    return ImpUtil::Equal(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
bool operator==(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    return ImpUtil::Equal(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
bool operator==(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    return ImpUtil::Equal(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
bool operator==(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    return ImpUtil::Equal(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
bool operator==(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    return ImpUtil::Equal(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
bool operator==(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    return ImpUtil::Equal(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
bool operator==(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    return ImpUtil::Equal(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
bool operator==(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    return ImpUtil::Equal(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
bool operator==(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    return ImpUtil::Equal(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
bool operator==(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    return ImpUtil::Equal(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
bool operator==(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    return ImpUtil::Equal(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
bool operator==(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    return ImpUtil::Equal(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
bool operator==(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    return ImpUtil::Equal(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
bool operator==(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    return ImpUtil::Equal(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
bool operator==(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    return ImpUtil::Equal(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
bool operator==(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16,
                                      t_TAIL_17>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16,
                                      t_TAIL_17>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    return ImpUtil::Equal(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
bool operator==(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16,
                                      t_TAIL_17,
                                      t_TAIL_18>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16,
                                      t_TAIL_17,
                                      t_TAIL_18>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    return ImpUtil::Equal(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 0
template <class t_HEAD>
bool operator!=(const variant<t_HEAD>& lhs,
                const variant<t_HEAD>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    return ImpUtil::NotEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 1
template <class t_HEAD, class t_TAIL_01>
bool operator!=(const variant<t_HEAD, t_TAIL_01>& lhs,
                const variant<t_HEAD, t_TAIL_01>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    return ImpUtil::NotEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
bool operator!=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    return ImpUtil::NotEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
bool operator!=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    return ImpUtil::NotEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
bool operator!=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    return ImpUtil::NotEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
bool operator!=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    return ImpUtil::NotEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
bool operator!=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    return ImpUtil::NotEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
bool operator!=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    return ImpUtil::NotEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
bool operator!=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    return ImpUtil::NotEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
bool operator!=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    return ImpUtil::NotEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
bool operator!=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    return ImpUtil::NotEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
bool operator!=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    return ImpUtil::NotEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
bool operator!=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    return ImpUtil::NotEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
bool operator!=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    return ImpUtil::NotEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
bool operator!=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    return ImpUtil::NotEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
bool operator!=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    return ImpUtil::NotEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
bool operator!=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    return ImpUtil::NotEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
bool operator!=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16,
                                      t_TAIL_17>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16,
                                      t_TAIL_17>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    return ImpUtil::NotEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
bool operator!=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16,
                                      t_TAIL_17,
                                      t_TAIL_18>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16,
                                      t_TAIL_17,
                                      t_TAIL_18>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    return ImpUtil::NotEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 0
template <class t_HEAD>
bool operator<(const variant<t_HEAD>& lhs,
               const variant<t_HEAD>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessThan(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 1
template <class t_HEAD, class t_TAIL_01>
bool operator<(const variant<t_HEAD, t_TAIL_01>& lhs,
               const variant<t_HEAD, t_TAIL_01>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessThan(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
bool operator<(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessThan(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
bool operator<(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessThan(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
bool operator<(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessThan(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
bool operator<(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessThan(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
bool operator<(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessThan(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
bool operator<(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessThan(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
bool operator<(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessThan(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
bool operator<(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessThan(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
bool operator<(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessThan(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
bool operator<(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessThan(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
bool operator<(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessThan(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
bool operator<(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessThan(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
bool operator<(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessThan(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
bool operator<(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14,
                                     t_TAIL_15>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14,
                                     t_TAIL_15>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessThan(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
bool operator<(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14,
                                     t_TAIL_15,
                                     t_TAIL_16>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14,
                                     t_TAIL_15,
                                     t_TAIL_16>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessThan(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
bool operator<(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14,
                                     t_TAIL_15,
                                     t_TAIL_16,
                                     t_TAIL_17>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14,
                                     t_TAIL_15,
                                     t_TAIL_16,
                                     t_TAIL_17>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessThan(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
bool operator<(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14,
                                     t_TAIL_15,
                                     t_TAIL_16,
                                     t_TAIL_17,
                                     t_TAIL_18>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14,
                                     t_TAIL_15,
                                     t_TAIL_16,
                                     t_TAIL_17,
                                     t_TAIL_18>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessThan(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 0
template <class t_HEAD>
bool operator>(const variant<t_HEAD>& lhs,
               const variant<t_HEAD>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
    return ImpUtil::GreaterThan(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 1
template <class t_HEAD, class t_TAIL_01>
bool operator>(const variant<t_HEAD, t_TAIL_01>& lhs,
               const variant<t_HEAD, t_TAIL_01>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
    return ImpUtil::GreaterThan(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
bool operator>(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
    return ImpUtil::GreaterThan(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
bool operator>(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
    return ImpUtil::GreaterThan(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
bool operator>(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
    return ImpUtil::GreaterThan(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
bool operator>(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
    return ImpUtil::GreaterThan(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
bool operator>(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
    return ImpUtil::GreaterThan(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
bool operator>(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
    return ImpUtil::GreaterThan(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
bool operator>(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
    return ImpUtil::GreaterThan(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
bool operator>(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
    return ImpUtil::GreaterThan(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
bool operator>(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
    return ImpUtil::GreaterThan(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
bool operator>(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
    return ImpUtil::GreaterThan(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
bool operator>(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
    return ImpUtil::GreaterThan(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
bool operator>(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
    return ImpUtil::GreaterThan(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
bool operator>(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
    return ImpUtil::GreaterThan(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
bool operator>(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14,
                                     t_TAIL_15>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14,
                                     t_TAIL_15>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
    return ImpUtil::GreaterThan(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
bool operator>(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14,
                                     t_TAIL_15,
                                     t_TAIL_16>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14,
                                     t_TAIL_15,
                                     t_TAIL_16>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
    return ImpUtil::GreaterThan(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
bool operator>(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14,
                                     t_TAIL_15,
                                     t_TAIL_16,
                                     t_TAIL_17>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14,
                                     t_TAIL_15,
                                     t_TAIL_16,
                                     t_TAIL_17>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
    return ImpUtil::GreaterThan(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
bool operator>(const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14,
                                     t_TAIL_15,
                                     t_TAIL_16,
                                     t_TAIL_17,
                                     t_TAIL_18>& lhs,
               const variant<t_HEAD, t_TAIL_01,
                                     t_TAIL_02,
                                     t_TAIL_03,
                                     t_TAIL_04,
                                     t_TAIL_05,
                                     t_TAIL_06,
                                     t_TAIL_07,
                                     t_TAIL_08,
                                     t_TAIL_09,
                                     t_TAIL_10,
                                     t_TAIL_11,
                                     t_TAIL_12,
                                     t_TAIL_13,
                                     t_TAIL_14,
                                     t_TAIL_15,
                                     t_TAIL_16,
                                     t_TAIL_17,
                                     t_TAIL_18>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
    return ImpUtil::GreaterThan(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 0
template <class t_HEAD>
bool operator<=(const variant<t_HEAD>& lhs,
                const variant<t_HEAD>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessOrEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 1
template <class t_HEAD, class t_TAIL_01>
bool operator<=(const variant<t_HEAD, t_TAIL_01>& lhs,
                const variant<t_HEAD, t_TAIL_01>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessOrEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
bool operator<=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessOrEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
bool operator<=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessOrEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
bool operator<=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessOrEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
bool operator<=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessOrEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
bool operator<=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessOrEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
bool operator<=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessOrEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
bool operator<=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessOrEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
bool operator<=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessOrEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
bool operator<=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessOrEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
bool operator<=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessOrEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
bool operator<=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessOrEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
bool operator<=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessOrEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
bool operator<=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessOrEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
bool operator<=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessOrEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
bool operator<=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessOrEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
bool operator<=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16,
                                      t_TAIL_17>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16,
                                      t_TAIL_17>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessOrEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
bool operator<=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16,
                                      t_TAIL_17,
                                      t_TAIL_18>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16,
                                      t_TAIL_17,
                                      t_TAIL_18>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessOrEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 18
 
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 0
template <class t_HEAD>
bool operator>=(const variant<t_HEAD>& lhs,
                const variant<t_HEAD>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
 
    return ImpUtil::GreaterOrEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 1
template <class t_HEAD, class t_TAIL_01>
bool operator>=(const variant<t_HEAD, t_TAIL_01>& lhs,
                const variant<t_HEAD, t_TAIL_01>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
 
    return ImpUtil::GreaterOrEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 2
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02>
bool operator>=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
 
    return ImpUtil::GreaterOrEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 3
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03>
bool operator>=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
 
    return ImpUtil::GreaterOrEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 4
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04>
bool operator>=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
 
    return ImpUtil::GreaterOrEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 5
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05>
bool operator>=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
 
    return ImpUtil::GreaterOrEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 6
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06>
bool operator>=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
 
    return ImpUtil::GreaterOrEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 7
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07>
bool operator>=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
 
    return ImpUtil::GreaterOrEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 8
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08>
bool operator>=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
 
    return ImpUtil::GreaterOrEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 9
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09>
bool operator>=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
 
    return ImpUtil::GreaterOrEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 10
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10>
bool operator>=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
 
    return ImpUtil::GreaterOrEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 11
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11>
bool operator>=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
 
    return ImpUtil::GreaterOrEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 12
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12>
bool operator>=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
 
    return ImpUtil::GreaterOrEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 13
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13>
bool operator>=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
 
    return ImpUtil::GreaterOrEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 14
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14>
bool operator>=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
 
    return ImpUtil::GreaterOrEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 15
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15>
bool operator>=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
 
    return ImpUtil::GreaterOrEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 16
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16>
bool operator>=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
 
    return ImpUtil::GreaterOrEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 17
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17>
bool operator>=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16,
                                      t_TAIL_17>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16,
                                      t_TAIL_17>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
 
    return ImpUtil::GreaterOrEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 18
template <class t_HEAD, class t_TAIL_01,
                        class t_TAIL_02,
                        class t_TAIL_03,
                        class t_TAIL_04,
                        class t_TAIL_05,
                        class t_TAIL_06,
                        class t_TAIL_07,
                        class t_TAIL_08,
                        class t_TAIL_09,
                        class t_TAIL_10,
                        class t_TAIL_11,
                        class t_TAIL_12,
                        class t_TAIL_13,
                        class t_TAIL_14,
                        class t_TAIL_15,
                        class t_TAIL_16,
                        class t_TAIL_17,
                        class t_TAIL_18>
bool operator>=(const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16,
                                      t_TAIL_17,
                                      t_TAIL_18>& lhs,
                const variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06,
                                      t_TAIL_07,
                                      t_TAIL_08,
                                      t_TAIL_09,
                                      t_TAIL_10,
                                      t_TAIL_11,
                                      t_TAIL_12,
                                      t_TAIL_13,
                                      t_TAIL_14,
                                      t_TAIL_15,
                                      t_TAIL_16,
                                      t_TAIL_17,
                                      t_TAIL_18>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
 
    return ImpUtil::GreaterOrEqual(lhs, rhs);
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 18
 
 
#if defined BSLS_COMPILERFEATURES_SUPPORT_THREE_WAY_COMPARISON &&             \
    defined BSLS_LIBRARYFEATURES_HAS_CPP20_CONCEPTS
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 0
requires()
constexpr std::common_comparison_category_t<
    >
operator<=>(const variant<>& lhs, const variant<>& rhs)
{
    using RET = std::common_comparison_category_t<
        >;
 
    const size_t lhs_index = lhs.index();
    const size_t rhs_index = rhs.index();
    if ((lhs_index != variant_npos) && (rhs_index != variant_npos)) {
        if (lhs_index == rhs_index) {
            return BloombergLP::bslstl::Variant_ImpUtil::visitId<RET>(
                    [&lhs]<size_t t_INDEX>(bsl::in_place_index_t<t_INDEX>,
                                           auto&& rhs_value) {
                        return bsl::get<t_INDEX>(lhs) <=> rhs_value;
                    },
                    rhs);
        }
        else {
            return lhs_index <=> rhs_index;
        }
    }
    else {
        if (lhs_index == variant_npos) {
            if (rhs_index == variant_npos)
                return std::strong_ordering::equal;
            else
                return std::strong_ordering::less;
        }
        else
            return std::strong_ordering::greater;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 0
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 1
template <class t_ALTS_01>
    requires(std::three_way_comparable<t_ALTS_01> && )
constexpr std::common_comparison_category_t<
    std::compare_three_way_result_t<t_ALTS_01>>
operator<=>(const variant<t_ALTS_01>& lhs, const variant<t_ALTS_01>& rhs)
{
    using RET = std::common_comparison_category_t<
        std::compare_three_way_result_t<t_ALTS_01>>;
 
    const size_t lhs_index = lhs.index();
    const size_t rhs_index = rhs.index();
    if ((lhs_index != variant_npos) && (rhs_index != variant_npos)) {
        if (lhs_index == rhs_index) {
            return BloombergLP::bslstl::Variant_ImpUtil::visitId<RET>(
                    [&lhs]<size_t t_INDEX>(bsl::in_place_index_t<t_INDEX>,
                                           auto&& rhs_value) {
                        return bsl::get<t_INDEX>(lhs) <=> rhs_value;
                    },
                    rhs);
        }
        else {
            return lhs_index <=> rhs_index;
        }
    }
    else {
        if (lhs_index == variant_npos) {
            if (rhs_index == variant_npos)
                return std::strong_ordering::equal;
            else
                return std::strong_ordering::less;
        }
        else
            return std::strong_ordering::greater;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 1
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 2
template <class t_ALTS_01,
          class t_ALTS_02>
    requires(std::three_way_comparable<t_ALTS_01> && ,
             std::three_way_comparable<t_ALTS_02> && )
constexpr std::common_comparison_category_t<
    std::compare_three_way_result_t<t_ALTS_01>,
    std::compare_three_way_result_t<t_ALTS_02>>
operator<=>(const variant<t_ALTS_01,
                          t_ALTS_02>& lhs, const variant<t_ALTS_01,
                                                         t_ALTS_02>& rhs)
{
    using RET = std::common_comparison_category_t<
        std::compare_three_way_result_t<t_ALTS_01>,
        std::compare_three_way_result_t<t_ALTS_02>>;
 
    const size_t lhs_index = lhs.index();
    const size_t rhs_index = rhs.index();
    if ((lhs_index != variant_npos) && (rhs_index != variant_npos)) {
        if (lhs_index == rhs_index) {
            return BloombergLP::bslstl::Variant_ImpUtil::visitId<RET>(
                    [&lhs]<size_t t_INDEX>(bsl::in_place_index_t<t_INDEX>,
                                           auto&& rhs_value) {
                        return bsl::get<t_INDEX>(lhs) <=> rhs_value;
                    },
                    rhs);
        }
        else {
            return lhs_index <=> rhs_index;
        }
    }
    else {
        if (lhs_index == variant_npos) {
            if (rhs_index == variant_npos)
                return std::strong_ordering::equal;
            else
                return std::strong_ordering::less;
        }
        else
            return std::strong_ordering::greater;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 2
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 3
template <class t_ALTS_01,
          class t_ALTS_02,
          class t_ALTS_03>
    requires(std::three_way_comparable<t_ALTS_01> && ,
             std::three_way_comparable<t_ALTS_02> && ,
             std::three_way_comparable<t_ALTS_03> && )
constexpr std::common_comparison_category_t<
    std::compare_three_way_result_t<t_ALTS_01>,
    std::compare_three_way_result_t<t_ALTS_02>,
    std::compare_three_way_result_t<t_ALTS_03>>
operator<=>(const variant<t_ALTS_01,
                          t_ALTS_02,
                          t_ALTS_03>& lhs, const variant<t_ALTS_01,
                                                         t_ALTS_02,
                                                         t_ALTS_03>& rhs)
{
    using RET = std::common_comparison_category_t<
        std::compare_three_way_result_t<t_ALTS_01>,
        std::compare_three_way_result_t<t_ALTS_02>,
        std::compare_three_way_result_t<t_ALTS_03>>;
 
    const size_t lhs_index = lhs.index();
    const size_t rhs_index = rhs.index();
    if ((lhs_index != variant_npos) && (rhs_index != variant_npos)) {
        if (lhs_index == rhs_index) {
            return BloombergLP::bslstl::Variant_ImpUtil::visitId<RET>(
                    [&lhs]<size_t t_INDEX>(bsl::in_place_index_t<t_INDEX>,
                                           auto&& rhs_value) {
                        return bsl::get<t_INDEX>(lhs) <=> rhs_value;
                    },
                    rhs);
        }
        else {
            return lhs_index <=> rhs_index;
        }
    }
    else {
        if (lhs_index == variant_npos) {
            if (rhs_index == variant_npos)
                return std::strong_ordering::equal;
            else
                return std::strong_ordering::less;
        }
        else
            return std::strong_ordering::greater;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 3
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 4
template <class t_ALTS_01,
          class t_ALTS_02,
          class t_ALTS_03,
          class t_ALTS_04>
    requires(std::three_way_comparable<t_ALTS_01> && ,
             std::three_way_comparable<t_ALTS_02> && ,
             std::three_way_comparable<t_ALTS_03> && ,
             std::three_way_comparable<t_ALTS_04> && )
constexpr std::common_comparison_category_t<
    std::compare_three_way_result_t<t_ALTS_01>,
    std::compare_three_way_result_t<t_ALTS_02>,
    std::compare_three_way_result_t<t_ALTS_03>,
    std::compare_three_way_result_t<t_ALTS_04>>
operator<=>(const variant<t_ALTS_01,
                          t_ALTS_02,
                          t_ALTS_03,
                          t_ALTS_04>& lhs, const variant<t_ALTS_01,
                                                         t_ALTS_02,
                                                         t_ALTS_03,
                                                         t_ALTS_04>& rhs)
{
    using RET = std::common_comparison_category_t<
        std::compare_three_way_result_t<t_ALTS_01>,
        std::compare_three_way_result_t<t_ALTS_02>,
        std::compare_three_way_result_t<t_ALTS_03>,
        std::compare_three_way_result_t<t_ALTS_04>>;
 
    const size_t lhs_index = lhs.index();
    const size_t rhs_index = rhs.index();
    if ((lhs_index != variant_npos) && (rhs_index != variant_npos)) {
        if (lhs_index == rhs_index) {
            return BloombergLP::bslstl::Variant_ImpUtil::visitId<RET>(
                    [&lhs]<size_t t_INDEX>(bsl::in_place_index_t<t_INDEX>,
                                           auto&& rhs_value) {
                        return bsl::get<t_INDEX>(lhs) <=> rhs_value;
                    },
                    rhs);
        }
        else {
            return lhs_index <=> rhs_index;
        }
    }
    else {
        if (lhs_index == variant_npos) {
            if (rhs_index == variant_npos)
                return std::strong_ordering::equal;
            else
                return std::strong_ordering::less;
        }
        else
            return std::strong_ordering::greater;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 4
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 5
template <class t_ALTS_01,
          class t_ALTS_02,
          class t_ALTS_03,
          class t_ALTS_04,
          class t_ALTS_05>
    requires(std::three_way_comparable<t_ALTS_01> && ,
             std::three_way_comparable<t_ALTS_02> && ,
             std::three_way_comparable<t_ALTS_03> && ,
             std::three_way_comparable<t_ALTS_04> && ,
             std::three_way_comparable<t_ALTS_05> && )
constexpr std::common_comparison_category_t<
    std::compare_three_way_result_t<t_ALTS_01>,
    std::compare_three_way_result_t<t_ALTS_02>,
    std::compare_three_way_result_t<t_ALTS_03>,
    std::compare_three_way_result_t<t_ALTS_04>,
    std::compare_three_way_result_t<t_ALTS_05>>
operator<=>(const variant<t_ALTS_01,
                          t_ALTS_02,
                          t_ALTS_03,
                          t_ALTS_04,
                          t_ALTS_05>& lhs, const variant<t_ALTS_01,
                                                         t_ALTS_02,
                                                         t_ALTS_03,
                                                         t_ALTS_04,
                                                         t_ALTS_05>& rhs)
{
    using RET = std::common_comparison_category_t<
        std::compare_three_way_result_t<t_ALTS_01>,
        std::compare_three_way_result_t<t_ALTS_02>,
        std::compare_three_way_result_t<t_ALTS_03>,
        std::compare_three_way_result_t<t_ALTS_04>,
        std::compare_three_way_result_t<t_ALTS_05>>;
 
    const size_t lhs_index = lhs.index();
    const size_t rhs_index = rhs.index();
    if ((lhs_index != variant_npos) && (rhs_index != variant_npos)) {
        if (lhs_index == rhs_index) {
            return BloombergLP::bslstl::Variant_ImpUtil::visitId<RET>(
                    [&lhs]<size_t t_INDEX>(bsl::in_place_index_t<t_INDEX>,
                                           auto&& rhs_value) {
                        return bsl::get<t_INDEX>(lhs) <=> rhs_value;
                    },
                    rhs);
        }
        else {
            return lhs_index <=> rhs_index;
        }
    }
    else {
        if (lhs_index == variant_npos) {
            if (rhs_index == variant_npos)
                return std::strong_ordering::equal;
            else
                return std::strong_ordering::less;
        }
        else
            return std::strong_ordering::greater;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 5
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 6
template <class t_ALTS_01,
          class t_ALTS_02,
          class t_ALTS_03,
          class t_ALTS_04,
          class t_ALTS_05,
          class t_ALTS_06>
    requires(std::three_way_comparable<t_ALTS_01> && ,
             std::three_way_comparable<t_ALTS_02> && ,
             std::three_way_comparable<t_ALTS_03> && ,
             std::three_way_comparable<t_ALTS_04> && ,
             std::three_way_comparable<t_ALTS_05> && ,
             std::three_way_comparable<t_ALTS_06> && )
constexpr std::common_comparison_category_t<
    std::compare_three_way_result_t<t_ALTS_01>,
    std::compare_three_way_result_t<t_ALTS_02>,
    std::compare_three_way_result_t<t_ALTS_03>,
    std::compare_three_way_result_t<t_ALTS_04>,
    std::compare_three_way_result_t<t_ALTS_05>,
    std::compare_three_way_result_t<t_ALTS_06>>
operator<=>(const variant<t_ALTS_01,
                          t_ALTS_02,
                          t_ALTS_03,
                          t_ALTS_04,
                          t_ALTS_05,
                          t_ALTS_06>& lhs, const variant<t_ALTS_01,
                                                         t_ALTS_02,
                                                         t_ALTS_03,
                                                         t_ALTS_04,
                                                         t_ALTS_05,
                                                         t_ALTS_06>& rhs)
{
    using RET = std::common_comparison_category_t<
        std::compare_three_way_result_t<t_ALTS_01>,
        std::compare_three_way_result_t<t_ALTS_02>,
        std::compare_three_way_result_t<t_ALTS_03>,
        std::compare_three_way_result_t<t_ALTS_04>,
        std::compare_three_way_result_t<t_ALTS_05>,
        std::compare_three_way_result_t<t_ALTS_06>>;
 
    const size_t lhs_index = lhs.index();
    const size_t rhs_index = rhs.index();
    if ((lhs_index != variant_npos) && (rhs_index != variant_npos)) {
        if (lhs_index == rhs_index) {
            return BloombergLP::bslstl::Variant_ImpUtil::visitId<RET>(
                    [&lhs]<size_t t_INDEX>(bsl::in_place_index_t<t_INDEX>,
                                           auto&& rhs_value) {
                        return bsl::get<t_INDEX>(lhs) <=> rhs_value;
                    },
                    rhs);
        }
        else {
            return lhs_index <=> rhs_index;
        }
    }
    else {
        if (lhs_index == variant_npos) {
            if (rhs_index == variant_npos)
                return std::strong_ordering::equal;
            else
                return std::strong_ordering::less;
        }
        else
            return std::strong_ordering::greater;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 6
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 7
template <class t_ALTS_01,
          class t_ALTS_02,
          class t_ALTS_03,
          class t_ALTS_04,
          class t_ALTS_05,
          class t_ALTS_06,
          class t_ALTS_07>
    requires(std::three_way_comparable<t_ALTS_01> && ,
             std::three_way_comparable<t_ALTS_02> && ,
             std::three_way_comparable<t_ALTS_03> && ,
             std::three_way_comparable<t_ALTS_04> && ,
             std::three_way_comparable<t_ALTS_05> && ,
             std::three_way_comparable<t_ALTS_06> && ,
             std::three_way_comparable<t_ALTS_07> && )
constexpr std::common_comparison_category_t<
    std::compare_three_way_result_t<t_ALTS_01>,
    std::compare_three_way_result_t<t_ALTS_02>,
    std::compare_three_way_result_t<t_ALTS_03>,
    std::compare_three_way_result_t<t_ALTS_04>,
    std::compare_three_way_result_t<t_ALTS_05>,
    std::compare_three_way_result_t<t_ALTS_06>,
    std::compare_three_way_result_t<t_ALTS_07>>
operator<=>(const variant<t_ALTS_01,
                          t_ALTS_02,
                          t_ALTS_03,
                          t_ALTS_04,
                          t_ALTS_05,
                          t_ALTS_06,
                          t_ALTS_07>& lhs, const variant<t_ALTS_01,
                                                         t_ALTS_02,
                                                         t_ALTS_03,
                                                         t_ALTS_04,
                                                         t_ALTS_05,
                                                         t_ALTS_06,
                                                         t_ALTS_07>& rhs)
{
    using RET = std::common_comparison_category_t<
        std::compare_three_way_result_t<t_ALTS_01>,
        std::compare_three_way_result_t<t_ALTS_02>,
        std::compare_three_way_result_t<t_ALTS_03>,
        std::compare_three_way_result_t<t_ALTS_04>,
        std::compare_three_way_result_t<t_ALTS_05>,
        std::compare_three_way_result_t<t_ALTS_06>,
        std::compare_three_way_result_t<t_ALTS_07>>;
 
    const size_t lhs_index = lhs.index();
    const size_t rhs_index = rhs.index();
    if ((lhs_index != variant_npos) && (rhs_index != variant_npos)) {
        if (lhs_index == rhs_index) {
            return BloombergLP::bslstl::Variant_ImpUtil::visitId<RET>(
                    [&lhs]<size_t t_INDEX>(bsl::in_place_index_t<t_INDEX>,
                                           auto&& rhs_value) {
                        return bsl::get<t_INDEX>(lhs) <=> rhs_value;
                    },
                    rhs);
        }
        else {
            return lhs_index <=> rhs_index;
        }
    }
    else {
        if (lhs_index == variant_npos) {
            if (rhs_index == variant_npos)
                return std::strong_ordering::equal;
            else
                return std::strong_ordering::less;
        }
        else
            return std::strong_ordering::greater;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 7
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 8
template <class t_ALTS_01,
          class t_ALTS_02,
          class t_ALTS_03,
          class t_ALTS_04,
          class t_ALTS_05,
          class t_ALTS_06,
          class t_ALTS_07,
          class t_ALTS_08>
    requires(std::three_way_comparable<t_ALTS_01> && ,
             std::three_way_comparable<t_ALTS_02> && ,
             std::three_way_comparable<t_ALTS_03> && ,
             std::three_way_comparable<t_ALTS_04> && ,
             std::three_way_comparable<t_ALTS_05> && ,
             std::three_way_comparable<t_ALTS_06> && ,
             std::three_way_comparable<t_ALTS_07> && ,
             std::three_way_comparable<t_ALTS_08> && )
constexpr std::common_comparison_category_t<
    std::compare_three_way_result_t<t_ALTS_01>,
    std::compare_three_way_result_t<t_ALTS_02>,
    std::compare_three_way_result_t<t_ALTS_03>,
    std::compare_three_way_result_t<t_ALTS_04>,
    std::compare_three_way_result_t<t_ALTS_05>,
    std::compare_three_way_result_t<t_ALTS_06>,
    std::compare_three_way_result_t<t_ALTS_07>,
    std::compare_three_way_result_t<t_ALTS_08>>
operator<=>(const variant<t_ALTS_01,
                          t_ALTS_02,
                          t_ALTS_03,
                          t_ALTS_04,
                          t_ALTS_05,
                          t_ALTS_06,
                          t_ALTS_07,
                          t_ALTS_08>& lhs, const variant<t_ALTS_01,
                                                         t_ALTS_02,
                                                         t_ALTS_03,
                                                         t_ALTS_04,
                                                         t_ALTS_05,
                                                         t_ALTS_06,
                                                         t_ALTS_07,
                                                         t_ALTS_08>& rhs)
{
    using RET = std::common_comparison_category_t<
        std::compare_three_way_result_t<t_ALTS_01>,
        std::compare_three_way_result_t<t_ALTS_02>,
        std::compare_three_way_result_t<t_ALTS_03>,
        std::compare_three_way_result_t<t_ALTS_04>,
        std::compare_three_way_result_t<t_ALTS_05>,
        std::compare_three_way_result_t<t_ALTS_06>,
        std::compare_three_way_result_t<t_ALTS_07>,
        std::compare_three_way_result_t<t_ALTS_08>>;
 
    const size_t lhs_index = lhs.index();
    const size_t rhs_index = rhs.index();
    if ((lhs_index != variant_npos) && (rhs_index != variant_npos)) {
        if (lhs_index == rhs_index) {
            return BloombergLP::bslstl::Variant_ImpUtil::visitId<RET>(
                    [&lhs]<size_t t_INDEX>(bsl::in_place_index_t<t_INDEX>,
                                           auto&& rhs_value) {
                        return bsl::get<t_INDEX>(lhs) <=> rhs_value;
                    },
                    rhs);
        }
        else {
            return lhs_index <=> rhs_index;
        }
    }
    else {
        if (lhs_index == variant_npos) {
            if (rhs_index == variant_npos)
                return std::strong_ordering::equal;
            else
                return std::strong_ordering::less;
        }
        else
            return std::strong_ordering::greater;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 8
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 9
template <class t_ALTS_01,
          class t_ALTS_02,
          class t_ALTS_03,
          class t_ALTS_04,
          class t_ALTS_05,
          class t_ALTS_06,
          class t_ALTS_07,
          class t_ALTS_08,
          class t_ALTS_09>
    requires(std::three_way_comparable<t_ALTS_01> && ,
             std::three_way_comparable<t_ALTS_02> && ,
             std::three_way_comparable<t_ALTS_03> && ,
             std::three_way_comparable<t_ALTS_04> && ,
             std::three_way_comparable<t_ALTS_05> && ,
             std::three_way_comparable<t_ALTS_06> && ,
             std::three_way_comparable<t_ALTS_07> && ,
             std::three_way_comparable<t_ALTS_08> && ,
             std::three_way_comparable<t_ALTS_09> && )
constexpr std::common_comparison_category_t<
    std::compare_three_way_result_t<t_ALTS_01>,
    std::compare_three_way_result_t<t_ALTS_02>,
    std::compare_three_way_result_t<t_ALTS_03>,
    std::compare_three_way_result_t<t_ALTS_04>,
    std::compare_three_way_result_t<t_ALTS_05>,
    std::compare_three_way_result_t<t_ALTS_06>,
    std::compare_three_way_result_t<t_ALTS_07>,
    std::compare_three_way_result_t<t_ALTS_08>,
    std::compare_three_way_result_t<t_ALTS_09>>
operator<=>(const variant<t_ALTS_01,
                          t_ALTS_02,
                          t_ALTS_03,
                          t_ALTS_04,
                          t_ALTS_05,
                          t_ALTS_06,
                          t_ALTS_07,
                          t_ALTS_08,
                          t_ALTS_09>& lhs, const variant<t_ALTS_01,
                                                         t_ALTS_02,
                                                         t_ALTS_03,
                                                         t_ALTS_04,
                                                         t_ALTS_05,
                                                         t_ALTS_06,
                                                         t_ALTS_07,
                                                         t_ALTS_08,
                                                         t_ALTS_09>& rhs)
{
    using RET = std::common_comparison_category_t<
        std::compare_three_way_result_t<t_ALTS_01>,
        std::compare_three_way_result_t<t_ALTS_02>,
        std::compare_three_way_result_t<t_ALTS_03>,
        std::compare_three_way_result_t<t_ALTS_04>,
        std::compare_three_way_result_t<t_ALTS_05>,
        std::compare_three_way_result_t<t_ALTS_06>,
        std::compare_three_way_result_t<t_ALTS_07>,
        std::compare_three_way_result_t<t_ALTS_08>,
        std::compare_three_way_result_t<t_ALTS_09>>;
 
    const size_t lhs_index = lhs.index();
    const size_t rhs_index = rhs.index();
    if ((lhs_index != variant_npos) && (rhs_index != variant_npos)) {
        if (lhs_index == rhs_index) {
            return BloombergLP::bslstl::Variant_ImpUtil::visitId<RET>(
                    [&lhs]<size_t t_INDEX>(bsl::in_place_index_t<t_INDEX>,
                                           auto&& rhs_value) {
                        return bsl::get<t_INDEX>(lhs) <=> rhs_value;
                    },
                    rhs);
        }
        else {
            return lhs_index <=> rhs_index;
        }
    }
    else {
        if (lhs_index == variant_npos) {
            if (rhs_index == variant_npos)
                return std::strong_ordering::equal;
            else
                return std::strong_ordering::less;
        }
        else
            return std::strong_ordering::greater;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 9
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 10
template <class t_ALTS_01,
          class t_ALTS_02,
          class t_ALTS_03,
          class t_ALTS_04,
          class t_ALTS_05,
          class t_ALTS_06,
          class t_ALTS_07,
          class t_ALTS_08,
          class t_ALTS_09,
          class t_ALTS_10>
    requires(std::three_way_comparable<t_ALTS_01> && ,
             std::three_way_comparable<t_ALTS_02> && ,
             std::three_way_comparable<t_ALTS_03> && ,
             std::three_way_comparable<t_ALTS_04> && ,
             std::three_way_comparable<t_ALTS_05> && ,
             std::three_way_comparable<t_ALTS_06> && ,
             std::three_way_comparable<t_ALTS_07> && ,
             std::three_way_comparable<t_ALTS_08> && ,
             std::three_way_comparable<t_ALTS_09> && ,
             std::three_way_comparable<t_ALTS_10> && )
constexpr std::common_comparison_category_t<
    std::compare_three_way_result_t<t_ALTS_01>,
    std::compare_three_way_result_t<t_ALTS_02>,
    std::compare_three_way_result_t<t_ALTS_03>,
    std::compare_three_way_result_t<t_ALTS_04>,
    std::compare_three_way_result_t<t_ALTS_05>,
    std::compare_three_way_result_t<t_ALTS_06>,
    std::compare_three_way_result_t<t_ALTS_07>,
    std::compare_three_way_result_t<t_ALTS_08>,
    std::compare_three_way_result_t<t_ALTS_09>,
    std::compare_three_way_result_t<t_ALTS_10>>
operator<=>(const variant<t_ALTS_01,
                          t_ALTS_02,
                          t_ALTS_03,
                          t_ALTS_04,
                          t_ALTS_05,
                          t_ALTS_06,
                          t_ALTS_07,
                          t_ALTS_08,
                          t_ALTS_09,
                          t_ALTS_10>& lhs, const variant<t_ALTS_01,
                                                         t_ALTS_02,
                                                         t_ALTS_03,
                                                         t_ALTS_04,
                                                         t_ALTS_05,
                                                         t_ALTS_06,
                                                         t_ALTS_07,
                                                         t_ALTS_08,
                                                         t_ALTS_09,
                                                         t_ALTS_10>& rhs)
{
    using RET = std::common_comparison_category_t<
        std::compare_three_way_result_t<t_ALTS_01>,
        std::compare_three_way_result_t<t_ALTS_02>,
        std::compare_three_way_result_t<t_ALTS_03>,
        std::compare_three_way_result_t<t_ALTS_04>,
        std::compare_three_way_result_t<t_ALTS_05>,
        std::compare_three_way_result_t<t_ALTS_06>,
        std::compare_three_way_result_t<t_ALTS_07>,
        std::compare_three_way_result_t<t_ALTS_08>,
        std::compare_three_way_result_t<t_ALTS_09>,
        std::compare_three_way_result_t<t_ALTS_10>>;
 
    const size_t lhs_index = lhs.index();
    const size_t rhs_index = rhs.index();
    if ((lhs_index != variant_npos) && (rhs_index != variant_npos)) {
        if (lhs_index == rhs_index) {
            return BloombergLP::bslstl::Variant_ImpUtil::visitId<RET>(
                    [&lhs]<size_t t_INDEX>(bsl::in_place_index_t<t_INDEX>,
                                           auto&& rhs_value) {
                        return bsl::get<t_INDEX>(lhs) <=> rhs_value;
                    },
                    rhs);
        }
        else {
            return lhs_index <=> rhs_index;
        }
    }
    else {
        if (lhs_index == variant_npos) {
            if (rhs_index == variant_npos)
                return std::strong_ordering::equal;
            else
                return std::strong_ordering::less;
        }
        else
            return std::strong_ordering::greater;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 10
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 11
template <class t_ALTS_01,
          class t_ALTS_02,
          class t_ALTS_03,
          class t_ALTS_04,
          class t_ALTS_05,
          class t_ALTS_06,
          class t_ALTS_07,
          class t_ALTS_08,
          class t_ALTS_09,
          class t_ALTS_10,
          class t_ALTS_11>
    requires(std::three_way_comparable<t_ALTS_01> && ,
             std::three_way_comparable<t_ALTS_02> && ,
             std::three_way_comparable<t_ALTS_03> && ,
             std::three_way_comparable<t_ALTS_04> && ,
             std::three_way_comparable<t_ALTS_05> && ,
             std::three_way_comparable<t_ALTS_06> && ,
             std::three_way_comparable<t_ALTS_07> && ,
             std::three_way_comparable<t_ALTS_08> && ,
             std::three_way_comparable<t_ALTS_09> && ,
             std::three_way_comparable<t_ALTS_10> && ,
             std::three_way_comparable<t_ALTS_11> && )
constexpr std::common_comparison_category_t<
    std::compare_three_way_result_t<t_ALTS_01>,
    std::compare_three_way_result_t<t_ALTS_02>,
    std::compare_three_way_result_t<t_ALTS_03>,
    std::compare_three_way_result_t<t_ALTS_04>,
    std::compare_three_way_result_t<t_ALTS_05>,
    std::compare_three_way_result_t<t_ALTS_06>,
    std::compare_three_way_result_t<t_ALTS_07>,
    std::compare_three_way_result_t<t_ALTS_08>,
    std::compare_three_way_result_t<t_ALTS_09>,
    std::compare_three_way_result_t<t_ALTS_10>,
    std::compare_three_way_result_t<t_ALTS_11>>
operator<=>(const variant<t_ALTS_01,
                          t_ALTS_02,
                          t_ALTS_03,
                          t_ALTS_04,
                          t_ALTS_05,
                          t_ALTS_06,
                          t_ALTS_07,
                          t_ALTS_08,
                          t_ALTS_09,
                          t_ALTS_10,
                          t_ALTS_11>& lhs, const variant<t_ALTS_01,
                                                         t_ALTS_02,
                                                         t_ALTS_03,
                                                         t_ALTS_04,
                                                         t_ALTS_05,
                                                         t_ALTS_06,
                                                         t_ALTS_07,
                                                         t_ALTS_08,
                                                         t_ALTS_09,
                                                         t_ALTS_10,
                                                         t_ALTS_11>& rhs)
{
    using RET = std::common_comparison_category_t<
        std::compare_three_way_result_t<t_ALTS_01>,
        std::compare_three_way_result_t<t_ALTS_02>,
        std::compare_three_way_result_t<t_ALTS_03>,
        std::compare_three_way_result_t<t_ALTS_04>,
        std::compare_three_way_result_t<t_ALTS_05>,
        std::compare_three_way_result_t<t_ALTS_06>,
        std::compare_three_way_result_t<t_ALTS_07>,
        std::compare_three_way_result_t<t_ALTS_08>,
        std::compare_three_way_result_t<t_ALTS_09>,
        std::compare_three_way_result_t<t_ALTS_10>,
        std::compare_three_way_result_t<t_ALTS_11>>;
 
    const size_t lhs_index = lhs.index();
    const size_t rhs_index = rhs.index();
    if ((lhs_index != variant_npos) && (rhs_index != variant_npos)) {
        if (lhs_index == rhs_index) {
            return BloombergLP::bslstl::Variant_ImpUtil::visitId<RET>(
                    [&lhs]<size_t t_INDEX>(bsl::in_place_index_t<t_INDEX>,
                                           auto&& rhs_value) {
                        return bsl::get<t_INDEX>(lhs) <=> rhs_value;
                    },
                    rhs);
        }
        else {
            return lhs_index <=> rhs_index;
        }
    }
    else {
        if (lhs_index == variant_npos) {
            if (rhs_index == variant_npos)
                return std::strong_ordering::equal;
            else
                return std::strong_ordering::less;
        }
        else
            return std::strong_ordering::greater;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 11
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 12
template <class t_ALTS_01,
          class t_ALTS_02,
          class t_ALTS_03,
          class t_ALTS_04,
          class t_ALTS_05,
          class t_ALTS_06,
          class t_ALTS_07,
          class t_ALTS_08,
          class t_ALTS_09,
          class t_ALTS_10,
          class t_ALTS_11,
          class t_ALTS_12>
    requires(std::three_way_comparable<t_ALTS_01> && ,
             std::three_way_comparable<t_ALTS_02> && ,
             std::three_way_comparable<t_ALTS_03> && ,
             std::three_way_comparable<t_ALTS_04> && ,
             std::three_way_comparable<t_ALTS_05> && ,
             std::three_way_comparable<t_ALTS_06> && ,
             std::three_way_comparable<t_ALTS_07> && ,
             std::three_way_comparable<t_ALTS_08> && ,
             std::three_way_comparable<t_ALTS_09> && ,
             std::three_way_comparable<t_ALTS_10> && ,
             std::three_way_comparable<t_ALTS_11> && ,
             std::three_way_comparable<t_ALTS_12> && )
constexpr std::common_comparison_category_t<
    std::compare_three_way_result_t<t_ALTS_01>,
    std::compare_three_way_result_t<t_ALTS_02>,
    std::compare_three_way_result_t<t_ALTS_03>,
    std::compare_three_way_result_t<t_ALTS_04>,
    std::compare_three_way_result_t<t_ALTS_05>,
    std::compare_three_way_result_t<t_ALTS_06>,
    std::compare_three_way_result_t<t_ALTS_07>,
    std::compare_three_way_result_t<t_ALTS_08>,
    std::compare_three_way_result_t<t_ALTS_09>,
    std::compare_three_way_result_t<t_ALTS_10>,
    std::compare_three_way_result_t<t_ALTS_11>,
    std::compare_three_way_result_t<t_ALTS_12>>
operator<=>(const variant<t_ALTS_01,
                          t_ALTS_02,
                          t_ALTS_03,
                          t_ALTS_04,
                          t_ALTS_05,
                          t_ALTS_06,
                          t_ALTS_07,
                          t_ALTS_08,
                          t_ALTS_09,
                          t_ALTS_10,
                          t_ALTS_11,
                          t_ALTS_12>& lhs, const variant<t_ALTS_01,
                                                         t_ALTS_02,
                                                         t_ALTS_03,
                                                         t_ALTS_04,
                                                         t_ALTS_05,
                                                         t_ALTS_06,
                                                         t_ALTS_07,
                                                         t_ALTS_08,
                                                         t_ALTS_09,
                                                         t_ALTS_10,
                                                         t_ALTS_11,
                                                         t_ALTS_12>& rhs)
{
    using RET = std::common_comparison_category_t<
        std::compare_three_way_result_t<t_ALTS_01>,
        std::compare_three_way_result_t<t_ALTS_02>,
        std::compare_three_way_result_t<t_ALTS_03>,
        std::compare_three_way_result_t<t_ALTS_04>,
        std::compare_three_way_result_t<t_ALTS_05>,
        std::compare_three_way_result_t<t_ALTS_06>,
        std::compare_three_way_result_t<t_ALTS_07>,
        std::compare_three_way_result_t<t_ALTS_08>,
        std::compare_three_way_result_t<t_ALTS_09>,
        std::compare_three_way_result_t<t_ALTS_10>,
        std::compare_three_way_result_t<t_ALTS_11>,
        std::compare_three_way_result_t<t_ALTS_12>>;
 
    const size_t lhs_index = lhs.index();
    const size_t rhs_index = rhs.index();
    if ((lhs_index != variant_npos) && (rhs_index != variant_npos)) {
        if (lhs_index == rhs_index) {
            return BloombergLP::bslstl::Variant_ImpUtil::visitId<RET>(
                    [&lhs]<size_t t_INDEX>(bsl::in_place_index_t<t_INDEX>,
                                           auto&& rhs_value) {
                        return bsl::get<t_INDEX>(lhs) <=> rhs_value;
                    },
                    rhs);
        }
        else {
            return lhs_index <=> rhs_index;
        }
    }
    else {
        if (lhs_index == variant_npos) {
            if (rhs_index == variant_npos)
                return std::strong_ordering::equal;
            else
                return std::strong_ordering::less;
        }
        else
            return std::strong_ordering::greater;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 12
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 13
template <class t_ALTS_01,
          class t_ALTS_02,
          class t_ALTS_03,
          class t_ALTS_04,
          class t_ALTS_05,
          class t_ALTS_06,
          class t_ALTS_07,
          class t_ALTS_08,
          class t_ALTS_09,
          class t_ALTS_10,
          class t_ALTS_11,
          class t_ALTS_12,
          class t_ALTS_13>
    requires(std::three_way_comparable<t_ALTS_01> && ,
             std::three_way_comparable<t_ALTS_02> && ,
             std::three_way_comparable<t_ALTS_03> && ,
             std::three_way_comparable<t_ALTS_04> && ,
             std::three_way_comparable<t_ALTS_05> && ,
             std::three_way_comparable<t_ALTS_06> && ,
             std::three_way_comparable<t_ALTS_07> && ,
             std::three_way_comparable<t_ALTS_08> && ,
             std::three_way_comparable<t_ALTS_09> && ,
             std::three_way_comparable<t_ALTS_10> && ,
             std::three_way_comparable<t_ALTS_11> && ,
             std::three_way_comparable<t_ALTS_12> && ,
             std::three_way_comparable<t_ALTS_13> && )
constexpr std::common_comparison_category_t<
    std::compare_three_way_result_t<t_ALTS_01>,
    std::compare_three_way_result_t<t_ALTS_02>,
    std::compare_three_way_result_t<t_ALTS_03>,
    std::compare_three_way_result_t<t_ALTS_04>,
    std::compare_three_way_result_t<t_ALTS_05>,
    std::compare_three_way_result_t<t_ALTS_06>,
    std::compare_three_way_result_t<t_ALTS_07>,
    std::compare_three_way_result_t<t_ALTS_08>,
    std::compare_three_way_result_t<t_ALTS_09>,
    std::compare_three_way_result_t<t_ALTS_10>,
    std::compare_three_way_result_t<t_ALTS_11>,
    std::compare_three_way_result_t<t_ALTS_12>,
    std::compare_three_way_result_t<t_ALTS_13>>
operator<=>(const variant<t_ALTS_01,
                          t_ALTS_02,
                          t_ALTS_03,
                          t_ALTS_04,
                          t_ALTS_05,
                          t_ALTS_06,
                          t_ALTS_07,
                          t_ALTS_08,
                          t_ALTS_09,
                          t_ALTS_10,
                          t_ALTS_11,
                          t_ALTS_12,
                          t_ALTS_13>& lhs, const variant<t_ALTS_01,
                                                         t_ALTS_02,
                                                         t_ALTS_03,
                                                         t_ALTS_04,
                                                         t_ALTS_05,
                                                         t_ALTS_06,
                                                         t_ALTS_07,
                                                         t_ALTS_08,
                                                         t_ALTS_09,
                                                         t_ALTS_10,
                                                         t_ALTS_11,
                                                         t_ALTS_12,
                                                         t_ALTS_13>& rhs)
{
    using RET = std::common_comparison_category_t<
        std::compare_three_way_result_t<t_ALTS_01>,
        std::compare_three_way_result_t<t_ALTS_02>,
        std::compare_three_way_result_t<t_ALTS_03>,
        std::compare_three_way_result_t<t_ALTS_04>,
        std::compare_three_way_result_t<t_ALTS_05>,
        std::compare_three_way_result_t<t_ALTS_06>,
        std::compare_three_way_result_t<t_ALTS_07>,
        std::compare_three_way_result_t<t_ALTS_08>,
        std::compare_three_way_result_t<t_ALTS_09>,
        std::compare_three_way_result_t<t_ALTS_10>,
        std::compare_three_way_result_t<t_ALTS_11>,
        std::compare_three_way_result_t<t_ALTS_12>,
        std::compare_three_way_result_t<t_ALTS_13>>;
 
    const size_t lhs_index = lhs.index();
    const size_t rhs_index = rhs.index();
    if ((lhs_index != variant_npos) && (rhs_index != variant_npos)) {
        if (lhs_index == rhs_index) {
            return BloombergLP::bslstl::Variant_ImpUtil::visitId<RET>(
                    [&lhs]<size_t t_INDEX>(bsl::in_place_index_t<t_INDEX>,
                                           auto&& rhs_value) {
                        return bsl::get<t_INDEX>(lhs) <=> rhs_value;
                    },
                    rhs);
        }
        else {
            return lhs_index <=> rhs_index;
        }
    }
    else {
        if (lhs_index == variant_npos) {
            if (rhs_index == variant_npos)
                return std::strong_ordering::equal;
            else
                return std::strong_ordering::less;
        }
        else
            return std::strong_ordering::greater;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 13
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 14
template <class t_ALTS_01,
          class t_ALTS_02,
          class t_ALTS_03,
          class t_ALTS_04,
          class t_ALTS_05,
          class t_ALTS_06,
          class t_ALTS_07,
          class t_ALTS_08,
          class t_ALTS_09,
          class t_ALTS_10,
          class t_ALTS_11,
          class t_ALTS_12,
          class t_ALTS_13,
          class t_ALTS_14>
    requires(std::three_way_comparable<t_ALTS_01> && ,
             std::three_way_comparable<t_ALTS_02> && ,
             std::three_way_comparable<t_ALTS_03> && ,
             std::three_way_comparable<t_ALTS_04> && ,
             std::three_way_comparable<t_ALTS_05> && ,
             std::three_way_comparable<t_ALTS_06> && ,
             std::three_way_comparable<t_ALTS_07> && ,
             std::three_way_comparable<t_ALTS_08> && ,
             std::three_way_comparable<t_ALTS_09> && ,
             std::three_way_comparable<t_ALTS_10> && ,
             std::three_way_comparable<t_ALTS_11> && ,
             std::three_way_comparable<t_ALTS_12> && ,
             std::three_way_comparable<t_ALTS_13> && ,
             std::three_way_comparable<t_ALTS_14> && )
constexpr std::common_comparison_category_t<
    std::compare_three_way_result_t<t_ALTS_01>,
    std::compare_three_way_result_t<t_ALTS_02>,
    std::compare_three_way_result_t<t_ALTS_03>,
    std::compare_three_way_result_t<t_ALTS_04>,
    std::compare_three_way_result_t<t_ALTS_05>,
    std::compare_three_way_result_t<t_ALTS_06>,
    std::compare_three_way_result_t<t_ALTS_07>,
    std::compare_three_way_result_t<t_ALTS_08>,
    std::compare_three_way_result_t<t_ALTS_09>,
    std::compare_three_way_result_t<t_ALTS_10>,
    std::compare_three_way_result_t<t_ALTS_11>,
    std::compare_three_way_result_t<t_ALTS_12>,
    std::compare_three_way_result_t<t_ALTS_13>,
    std::compare_three_way_result_t<t_ALTS_14>>
operator<=>(const variant<t_ALTS_01,
                          t_ALTS_02,
                          t_ALTS_03,
                          t_ALTS_04,
                          t_ALTS_05,
                          t_ALTS_06,
                          t_ALTS_07,
                          t_ALTS_08,
                          t_ALTS_09,
                          t_ALTS_10,
                          t_ALTS_11,
                          t_ALTS_12,
                          t_ALTS_13,
                          t_ALTS_14>& lhs, const variant<t_ALTS_01,
                                                         t_ALTS_02,
                                                         t_ALTS_03,
                                                         t_ALTS_04,
                                                         t_ALTS_05,
                                                         t_ALTS_06,
                                                         t_ALTS_07,
                                                         t_ALTS_08,
                                                         t_ALTS_09,
                                                         t_ALTS_10,
                                                         t_ALTS_11,
                                                         t_ALTS_12,
                                                         t_ALTS_13,
                                                         t_ALTS_14>& rhs)
{
    using RET = std::common_comparison_category_t<
        std::compare_three_way_result_t<t_ALTS_01>,
        std::compare_three_way_result_t<t_ALTS_02>,
        std::compare_three_way_result_t<t_ALTS_03>,
        std::compare_three_way_result_t<t_ALTS_04>,
        std::compare_three_way_result_t<t_ALTS_05>,
        std::compare_three_way_result_t<t_ALTS_06>,
        std::compare_three_way_result_t<t_ALTS_07>,
        std::compare_three_way_result_t<t_ALTS_08>,
        std::compare_three_way_result_t<t_ALTS_09>,
        std::compare_three_way_result_t<t_ALTS_10>,
        std::compare_three_way_result_t<t_ALTS_11>,
        std::compare_three_way_result_t<t_ALTS_12>,
        std::compare_three_way_result_t<t_ALTS_13>,
        std::compare_three_way_result_t<t_ALTS_14>>;
 
    const size_t lhs_index = lhs.index();
    const size_t rhs_index = rhs.index();
    if ((lhs_index != variant_npos) && (rhs_index != variant_npos)) {
        if (lhs_index == rhs_index) {
            return BloombergLP::bslstl::Variant_ImpUtil::visitId<RET>(
                    [&lhs]<size_t t_INDEX>(bsl::in_place_index_t<t_INDEX>,
                                           auto&& rhs_value) {
                        return bsl::get<t_INDEX>(lhs) <=> rhs_value;
                    },
                    rhs);
        }
        else {
            return lhs_index <=> rhs_index;
        }
    }
    else {
        if (lhs_index == variant_npos) {
            if (rhs_index == variant_npos)
                return std::strong_ordering::equal;
            else
                return std::strong_ordering::less;
        }
        else
            return std::strong_ordering::greater;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 14
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 15
template <class t_ALTS_01,
          class t_ALTS_02,
          class t_ALTS_03,
          class t_ALTS_04,
          class t_ALTS_05,
          class t_ALTS_06,
          class t_ALTS_07,
          class t_ALTS_08,
          class t_ALTS_09,
          class t_ALTS_10,
          class t_ALTS_11,
          class t_ALTS_12,
          class t_ALTS_13,
          class t_ALTS_14,
          class t_ALTS_15>
    requires(std::three_way_comparable<t_ALTS_01> && ,
             std::three_way_comparable<t_ALTS_02> && ,
             std::three_way_comparable<t_ALTS_03> && ,
             std::three_way_comparable<t_ALTS_04> && ,
             std::three_way_comparable<t_ALTS_05> && ,
             std::three_way_comparable<t_ALTS_06> && ,
             std::three_way_comparable<t_ALTS_07> && ,
             std::three_way_comparable<t_ALTS_08> && ,
             std::three_way_comparable<t_ALTS_09> && ,
             std::three_way_comparable<t_ALTS_10> && ,
             std::three_way_comparable<t_ALTS_11> && ,
             std::three_way_comparable<t_ALTS_12> && ,
             std::three_way_comparable<t_ALTS_13> && ,
             std::three_way_comparable<t_ALTS_14> && ,
             std::three_way_comparable<t_ALTS_15> && )
constexpr std::common_comparison_category_t<
    std::compare_three_way_result_t<t_ALTS_01>,
    std::compare_three_way_result_t<t_ALTS_02>,
    std::compare_three_way_result_t<t_ALTS_03>,
    std::compare_three_way_result_t<t_ALTS_04>,
    std::compare_three_way_result_t<t_ALTS_05>,
    std::compare_three_way_result_t<t_ALTS_06>,
    std::compare_three_way_result_t<t_ALTS_07>,
    std::compare_three_way_result_t<t_ALTS_08>,
    std::compare_three_way_result_t<t_ALTS_09>,
    std::compare_three_way_result_t<t_ALTS_10>,
    std::compare_three_way_result_t<t_ALTS_11>,
    std::compare_three_way_result_t<t_ALTS_12>,
    std::compare_three_way_result_t<t_ALTS_13>,
    std::compare_three_way_result_t<t_ALTS_14>,
    std::compare_three_way_result_t<t_ALTS_15>>
operator<=>(const variant<t_ALTS_01,
                          t_ALTS_02,
                          t_ALTS_03,
                          t_ALTS_04,
                          t_ALTS_05,
                          t_ALTS_06,
                          t_ALTS_07,
                          t_ALTS_08,
                          t_ALTS_09,
                          t_ALTS_10,
                          t_ALTS_11,
                          t_ALTS_12,
                          t_ALTS_13,
                          t_ALTS_14,
                          t_ALTS_15>& lhs, const variant<t_ALTS_01,
                                                         t_ALTS_02,
                                                         t_ALTS_03,
                                                         t_ALTS_04,
                                                         t_ALTS_05,
                                                         t_ALTS_06,
                                                         t_ALTS_07,
                                                         t_ALTS_08,
                                                         t_ALTS_09,
                                                         t_ALTS_10,
                                                         t_ALTS_11,
                                                         t_ALTS_12,
                                                         t_ALTS_13,
                                                         t_ALTS_14,
                                                         t_ALTS_15>& rhs)
{
    using RET = std::common_comparison_category_t<
        std::compare_three_way_result_t<t_ALTS_01>,
        std::compare_three_way_result_t<t_ALTS_02>,
        std::compare_three_way_result_t<t_ALTS_03>,
        std::compare_three_way_result_t<t_ALTS_04>,
        std::compare_three_way_result_t<t_ALTS_05>,
        std::compare_three_way_result_t<t_ALTS_06>,
        std::compare_three_way_result_t<t_ALTS_07>,
        std::compare_three_way_result_t<t_ALTS_08>,
        std::compare_three_way_result_t<t_ALTS_09>,
        std::compare_three_way_result_t<t_ALTS_10>,
        std::compare_three_way_result_t<t_ALTS_11>,
        std::compare_three_way_result_t<t_ALTS_12>,
        std::compare_three_way_result_t<t_ALTS_13>,
        std::compare_three_way_result_t<t_ALTS_14>,
        std::compare_three_way_result_t<t_ALTS_15>>;
 
    const size_t lhs_index = lhs.index();
    const size_t rhs_index = rhs.index();
    if ((lhs_index != variant_npos) && (rhs_index != variant_npos)) {
        if (lhs_index == rhs_index) {
            return BloombergLP::bslstl::Variant_ImpUtil::visitId<RET>(
                    [&lhs]<size_t t_INDEX>(bsl::in_place_index_t<t_INDEX>,
                                           auto&& rhs_value) {
                        return bsl::get<t_INDEX>(lhs) <=> rhs_value;
                    },
                    rhs);
        }
        else {
            return lhs_index <=> rhs_index;
        }
    }
    else {
        if (lhs_index == variant_npos) {
            if (rhs_index == variant_npos)
                return std::strong_ordering::equal;
            else
                return std::strong_ordering::less;
        }
        else
            return std::strong_ordering::greater;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 15
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 16
template <class t_ALTS_01,
          class t_ALTS_02,
          class t_ALTS_03,
          class t_ALTS_04,
          class t_ALTS_05,
          class t_ALTS_06,
          class t_ALTS_07,
          class t_ALTS_08,
          class t_ALTS_09,
          class t_ALTS_10,
          class t_ALTS_11,
          class t_ALTS_12,
          class t_ALTS_13,
          class t_ALTS_14,
          class t_ALTS_15,
          class t_ALTS_16>
    requires(std::three_way_comparable<t_ALTS_01> && ,
             std::three_way_comparable<t_ALTS_02> && ,
             std::three_way_comparable<t_ALTS_03> && ,
             std::three_way_comparable<t_ALTS_04> && ,
             std::three_way_comparable<t_ALTS_05> && ,
             std::three_way_comparable<t_ALTS_06> && ,
             std::three_way_comparable<t_ALTS_07> && ,
             std::three_way_comparable<t_ALTS_08> && ,
             std::three_way_comparable<t_ALTS_09> && ,
             std::three_way_comparable<t_ALTS_10> && ,
             std::three_way_comparable<t_ALTS_11> && ,
             std::three_way_comparable<t_ALTS_12> && ,
             std::three_way_comparable<t_ALTS_13> && ,
             std::three_way_comparable<t_ALTS_14> && ,
             std::three_way_comparable<t_ALTS_15> && ,
             std::three_way_comparable<t_ALTS_16> && )
constexpr std::common_comparison_category_t<
    std::compare_three_way_result_t<t_ALTS_01>,
    std::compare_three_way_result_t<t_ALTS_02>,
    std::compare_three_way_result_t<t_ALTS_03>,
    std::compare_three_way_result_t<t_ALTS_04>,
    std::compare_three_way_result_t<t_ALTS_05>,
    std::compare_three_way_result_t<t_ALTS_06>,
    std::compare_three_way_result_t<t_ALTS_07>,
    std::compare_three_way_result_t<t_ALTS_08>,
    std::compare_three_way_result_t<t_ALTS_09>,
    std::compare_three_way_result_t<t_ALTS_10>,
    std::compare_three_way_result_t<t_ALTS_11>,
    std::compare_three_way_result_t<t_ALTS_12>,
    std::compare_three_way_result_t<t_ALTS_13>,
    std::compare_three_way_result_t<t_ALTS_14>,
    std::compare_three_way_result_t<t_ALTS_15>,
    std::compare_three_way_result_t<t_ALTS_16>>
operator<=>(const variant<t_ALTS_01,
                          t_ALTS_02,
                          t_ALTS_03,
                          t_ALTS_04,
                          t_ALTS_05,
                          t_ALTS_06,
                          t_ALTS_07,
                          t_ALTS_08,
                          t_ALTS_09,
                          t_ALTS_10,
                          t_ALTS_11,
                          t_ALTS_12,
                          t_ALTS_13,
                          t_ALTS_14,
                          t_ALTS_15,
                          t_ALTS_16>& lhs, const variant<t_ALTS_01,
                                                         t_ALTS_02,
                                                         t_ALTS_03,
                                                         t_ALTS_04,
                                                         t_ALTS_05,
                                                         t_ALTS_06,
                                                         t_ALTS_07,
                                                         t_ALTS_08,
                                                         t_ALTS_09,
                                                         t_ALTS_10,
                                                         t_ALTS_11,
                                                         t_ALTS_12,
                                                         t_ALTS_13,
                                                         t_ALTS_14,
                                                         t_ALTS_15,
                                                         t_ALTS_16>& rhs)
{
    using RET = std::common_comparison_category_t<
        std::compare_three_way_result_t<t_ALTS_01>,
        std::compare_three_way_result_t<t_ALTS_02>,
        std::compare_three_way_result_t<t_ALTS_03>,
        std::compare_three_way_result_t<t_ALTS_04>,
        std::compare_three_way_result_t<t_ALTS_05>,
        std::compare_three_way_result_t<t_ALTS_06>,
        std::compare_three_way_result_t<t_ALTS_07>,
        std::compare_three_way_result_t<t_ALTS_08>,
        std::compare_three_way_result_t<t_ALTS_09>,
        std::compare_three_way_result_t<t_ALTS_10>,
        std::compare_three_way_result_t<t_ALTS_11>,
        std::compare_three_way_result_t<t_ALTS_12>,
        std::compare_three_way_result_t<t_ALTS_13>,
        std::compare_three_way_result_t<t_ALTS_14>,
        std::compare_three_way_result_t<t_ALTS_15>,
        std::compare_three_way_result_t<t_ALTS_16>>;
 
    const size_t lhs_index = lhs.index();
    const size_t rhs_index = rhs.index();
    if ((lhs_index != variant_npos) && (rhs_index != variant_npos)) {
        if (lhs_index == rhs_index) {
            return BloombergLP::bslstl::Variant_ImpUtil::visitId<RET>(
                    [&lhs]<size_t t_INDEX>(bsl::in_place_index_t<t_INDEX>,
                                           auto&& rhs_value) {
                        return bsl::get<t_INDEX>(lhs) <=> rhs_value;
                    },
                    rhs);
        }
        else {
            return lhs_index <=> rhs_index;
        }
    }
    else {
        if (lhs_index == variant_npos) {
            if (rhs_index == variant_npos)
                return std::strong_ordering::equal;
            else
                return std::strong_ordering::less;
        }
        else
            return std::strong_ordering::greater;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 16
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 17
template <class t_ALTS_01,
          class t_ALTS_02,
          class t_ALTS_03,
          class t_ALTS_04,
          class t_ALTS_05,
          class t_ALTS_06,
          class t_ALTS_07,
          class t_ALTS_08,
          class t_ALTS_09,
          class t_ALTS_10,
          class t_ALTS_11,
          class t_ALTS_12,
          class t_ALTS_13,
          class t_ALTS_14,
          class t_ALTS_15,
          class t_ALTS_16,
          class t_ALTS_17>
    requires(std::three_way_comparable<t_ALTS_01> && ,
             std::three_way_comparable<t_ALTS_02> && ,
             std::three_way_comparable<t_ALTS_03> && ,
             std::three_way_comparable<t_ALTS_04> && ,
             std::three_way_comparable<t_ALTS_05> && ,
             std::three_way_comparable<t_ALTS_06> && ,
             std::three_way_comparable<t_ALTS_07> && ,
             std::three_way_comparable<t_ALTS_08> && ,
             std::three_way_comparable<t_ALTS_09> && ,
             std::three_way_comparable<t_ALTS_10> && ,
             std::three_way_comparable<t_ALTS_11> && ,
             std::three_way_comparable<t_ALTS_12> && ,
             std::three_way_comparable<t_ALTS_13> && ,
             std::three_way_comparable<t_ALTS_14> && ,
             std::three_way_comparable<t_ALTS_15> && ,
             std::three_way_comparable<t_ALTS_16> && ,
             std::three_way_comparable<t_ALTS_17> && )
constexpr std::common_comparison_category_t<
    std::compare_three_way_result_t<t_ALTS_01>,
    std::compare_three_way_result_t<t_ALTS_02>,
    std::compare_three_way_result_t<t_ALTS_03>,
    std::compare_three_way_result_t<t_ALTS_04>,
    std::compare_three_way_result_t<t_ALTS_05>,
    std::compare_three_way_result_t<t_ALTS_06>,
    std::compare_three_way_result_t<t_ALTS_07>,
    std::compare_three_way_result_t<t_ALTS_08>,
    std::compare_three_way_result_t<t_ALTS_09>,
    std::compare_three_way_result_t<t_ALTS_10>,
    std::compare_three_way_result_t<t_ALTS_11>,
    std::compare_three_way_result_t<t_ALTS_12>,
    std::compare_three_way_result_t<t_ALTS_13>,
    std::compare_three_way_result_t<t_ALTS_14>,
    std::compare_three_way_result_t<t_ALTS_15>,
    std::compare_three_way_result_t<t_ALTS_16>,
    std::compare_three_way_result_t<t_ALTS_17>>
operator<=>(const variant<t_ALTS_01,
                          t_ALTS_02,
                          t_ALTS_03,
                          t_ALTS_04,
                          t_ALTS_05,
                          t_ALTS_06,
                          t_ALTS_07,
                          t_ALTS_08,
                          t_ALTS_09,
                          t_ALTS_10,
                          t_ALTS_11,
                          t_ALTS_12,
                          t_ALTS_13,
                          t_ALTS_14,
                          t_ALTS_15,
                          t_ALTS_16,
                          t_ALTS_17>& lhs, const variant<t_ALTS_01,
                                                         t_ALTS_02,
                                                         t_ALTS_03,
                                                         t_ALTS_04,
                                                         t_ALTS_05,
                                                         t_ALTS_06,
                                                         t_ALTS_07,
                                                         t_ALTS_08,
                                                         t_ALTS_09,
                                                         t_ALTS_10,
                                                         t_ALTS_11,
                                                         t_ALTS_12,
                                                         t_ALTS_13,
                                                         t_ALTS_14,
                                                         t_ALTS_15,
                                                         t_ALTS_16,
                                                         t_ALTS_17>& rhs)
{
    using RET = std::common_comparison_category_t<
        std::compare_three_way_result_t<t_ALTS_01>,
        std::compare_three_way_result_t<t_ALTS_02>,
        std::compare_three_way_result_t<t_ALTS_03>,
        std::compare_three_way_result_t<t_ALTS_04>,
        std::compare_three_way_result_t<t_ALTS_05>,
        std::compare_three_way_result_t<t_ALTS_06>,
        std::compare_three_way_result_t<t_ALTS_07>,
        std::compare_three_way_result_t<t_ALTS_08>,
        std::compare_three_way_result_t<t_ALTS_09>,
        std::compare_three_way_result_t<t_ALTS_10>,
        std::compare_three_way_result_t<t_ALTS_11>,
        std::compare_three_way_result_t<t_ALTS_12>,
        std::compare_three_way_result_t<t_ALTS_13>,
        std::compare_three_way_result_t<t_ALTS_14>,
        std::compare_three_way_result_t<t_ALTS_15>,
        std::compare_three_way_result_t<t_ALTS_16>,
        std::compare_three_way_result_t<t_ALTS_17>>;
 
    const size_t lhs_index = lhs.index();
    const size_t rhs_index = rhs.index();
    if ((lhs_index != variant_npos) && (rhs_index != variant_npos)) {
        if (lhs_index == rhs_index) {
            return BloombergLP::bslstl::Variant_ImpUtil::visitId<RET>(
                    [&lhs]<size_t t_INDEX>(bsl::in_place_index_t<t_INDEX>,
                                           auto&& rhs_value) {
                        return bsl::get<t_INDEX>(lhs) <=> rhs_value;
                    },
                    rhs);
        }
        else {
            return lhs_index <=> rhs_index;
        }
    }
    else {
        if (lhs_index == variant_npos) {
            if (rhs_index == variant_npos)
                return std::strong_ordering::equal;
            else
                return std::strong_ordering::less;
        }
        else
            return std::strong_ordering::greater;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 17
 
#if BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 18
template <class t_ALTS_01,
          class t_ALTS_02,
          class t_ALTS_03,
          class t_ALTS_04,
          class t_ALTS_05,
          class t_ALTS_06,
          class t_ALTS_07,
          class t_ALTS_08,
          class t_ALTS_09,
          class t_ALTS_10,
          class t_ALTS_11,
          class t_ALTS_12,
          class t_ALTS_13,
          class t_ALTS_14,
          class t_ALTS_15,
          class t_ALTS_16,
          class t_ALTS_17,
          class t_ALTS_18>
    requires(std::three_way_comparable<t_ALTS_01> && ,
             std::three_way_comparable<t_ALTS_02> && ,
             std::three_way_comparable<t_ALTS_03> && ,
             std::three_way_comparable<t_ALTS_04> && ,
             std::three_way_comparable<t_ALTS_05> && ,
             std::three_way_comparable<t_ALTS_06> && ,
             std::three_way_comparable<t_ALTS_07> && ,
             std::three_way_comparable<t_ALTS_08> && ,
             std::three_way_comparable<t_ALTS_09> && ,
             std::three_way_comparable<t_ALTS_10> && ,
             std::three_way_comparable<t_ALTS_11> && ,
             std::three_way_comparable<t_ALTS_12> && ,
             std::three_way_comparable<t_ALTS_13> && ,
             std::three_way_comparable<t_ALTS_14> && ,
             std::three_way_comparable<t_ALTS_15> && ,
             std::three_way_comparable<t_ALTS_16> && ,
             std::three_way_comparable<t_ALTS_17> && ,
             std::three_way_comparable<t_ALTS_18> && )
constexpr std::common_comparison_category_t<
    std::compare_three_way_result_t<t_ALTS_01>,
    std::compare_three_way_result_t<t_ALTS_02>,
    std::compare_three_way_result_t<t_ALTS_03>,
    std::compare_three_way_result_t<t_ALTS_04>,
    std::compare_three_way_result_t<t_ALTS_05>,
    std::compare_three_way_result_t<t_ALTS_06>,
    std::compare_three_way_result_t<t_ALTS_07>,
    std::compare_three_way_result_t<t_ALTS_08>,
    std::compare_three_way_result_t<t_ALTS_09>,
    std::compare_three_way_result_t<t_ALTS_10>,
    std::compare_three_way_result_t<t_ALTS_11>,
    std::compare_three_way_result_t<t_ALTS_12>,
    std::compare_three_way_result_t<t_ALTS_13>,
    std::compare_three_way_result_t<t_ALTS_14>,
    std::compare_three_way_result_t<t_ALTS_15>,
    std::compare_three_way_result_t<t_ALTS_16>,
    std::compare_three_way_result_t<t_ALTS_17>,
    std::compare_three_way_result_t<t_ALTS_18>>
operator<=>(const variant<t_ALTS_01,
                          t_ALTS_02,
                          t_ALTS_03,
                          t_ALTS_04,
                          t_ALTS_05,
                          t_ALTS_06,
                          t_ALTS_07,
                          t_ALTS_08,
                          t_ALTS_09,
                          t_ALTS_10,
                          t_ALTS_11,
                          t_ALTS_12,
                          t_ALTS_13,
                          t_ALTS_14,
                          t_ALTS_15,
                          t_ALTS_16,
                          t_ALTS_17,
                          t_ALTS_18>& lhs, const variant<t_ALTS_01,
                                                         t_ALTS_02,
                                                         t_ALTS_03,
                                                         t_ALTS_04,
                                                         t_ALTS_05,
                                                         t_ALTS_06,
                                                         t_ALTS_07,
                                                         t_ALTS_08,
                                                         t_ALTS_09,
                                                         t_ALTS_10,
                                                         t_ALTS_11,
                                                         t_ALTS_12,
                                                         t_ALTS_13,
                                                         t_ALTS_14,
                                                         t_ALTS_15,
                                                         t_ALTS_16,
                                                         t_ALTS_17,
                                                         t_ALTS_18>& rhs)
{
    using RET = std::common_comparison_category_t<
        std::compare_three_way_result_t<t_ALTS_01>,
        std::compare_three_way_result_t<t_ALTS_02>,
        std::compare_three_way_result_t<t_ALTS_03>,
        std::compare_three_way_result_t<t_ALTS_04>,
        std::compare_three_way_result_t<t_ALTS_05>,
        std::compare_three_way_result_t<t_ALTS_06>,
        std::compare_three_way_result_t<t_ALTS_07>,
        std::compare_three_way_result_t<t_ALTS_08>,
        std::compare_three_way_result_t<t_ALTS_09>,
        std::compare_three_way_result_t<t_ALTS_10>,
        std::compare_three_way_result_t<t_ALTS_11>,
        std::compare_three_way_result_t<t_ALTS_12>,
        std::compare_three_way_result_t<t_ALTS_13>,
        std::compare_three_way_result_t<t_ALTS_14>,
        std::compare_three_way_result_t<t_ALTS_15>,
        std::compare_three_way_result_t<t_ALTS_16>,
        std::compare_three_way_result_t<t_ALTS_17>,
        std::compare_three_way_result_t<t_ALTS_18>>;
 
    const size_t lhs_index = lhs.index();
    const size_t rhs_index = rhs.index();
    if ((lhs_index != variant_npos) && (rhs_index != variant_npos)) {
        if (lhs_index == rhs_index) {
            return BloombergLP::bslstl::Variant_ImpUtil::visitId<RET>(
                    [&lhs]<size_t t_INDEX>(bsl::in_place_index_t<t_INDEX>,
                                           auto&& rhs_value) {
                        return bsl::get<t_INDEX>(lhs) <=> rhs_value;
                    },
                    rhs);
        }
        else {
            return lhs_index <=> rhs_index;
        }
    }
    else {
        if (lhs_index == variant_npos) {
            if (rhs_index == variant_npos)
                return std::strong_ordering::equal;
            else
                return std::strong_ordering::less;
        }
        else
            return std::strong_ordering::greater;
    }
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_U >= 18
 
#endif
#else
// The generated code below is a workaround for the absence of perfect
// forwarding in some compilers.
template <class t_HASHALG, class t_HEAD, class... t_TAIL>
void hashAppend(t_HASHALG& hashAlg, const variant<t_HEAD, t_TAIL...>& input)
{
    if (!input.valueless_by_exception()) {
        hashAppend(hashAlg, input.index());
        BloombergLP::bslstl::Variant_HashVisitor<t_HASHALG> hashVisitor(
                                                                      hashAlg);
        visit(hashVisitor, input);
    }
    else {
        hashAppend(hashAlg, false);
    }
}
 
template <class t_TYPE, class t_HEAD, class... t_TAIL>
bool holds_alternative(
                   const variant<t_HEAD, t_TAIL...>& obj) BSLS_KEYWORD_NOEXCEPT
{
    BSLMF_ASSERT((BloombergLP::bslstl::Variant_HasUniqueType<
                  t_TYPE,
                  variant<t_HEAD, t_TAIL...> >::value));
    typedef typename bsl::variant<t_HEAD, t_TAIL...> Variant;
    return obj.index() == BSLSTL_VARIANT_INDEX_OF(t_TYPE, Variant);
}
 
template <class t_HEAD, class... t_TAIL>
void swap(bsl::variant<t_HEAD, t_TAIL...>& lhs,
          bsl::variant<t_HEAD, t_TAIL...>& rhs)
{
    BloombergLP::bslstl::variant_swapImpl(
        bsl::integral_constant<
            bool,
            BloombergLP::bslstl::
                Variant_UsesBslmaAllocatorAny<t_HEAD, t_TAIL...>::value>(),
        lhs,
        rhs);
}
 
template <class t_HEAD, class... t_TAIL>
bool operator==(const variant<t_HEAD, t_TAIL...>& lhs,
                const variant<t_HEAD, t_TAIL...>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    return ImpUtil::Equal(lhs, rhs);
}
 
template <class t_HEAD, class... t_TAIL>
bool operator!=(const variant<t_HEAD, t_TAIL...>& lhs,
                const variant<t_HEAD, t_TAIL...>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.index() != rhs.index()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    return ImpUtil::NotEqual(lhs, rhs);
}
 
template <class t_HEAD, class... t_TAIL>
bool operator<(const variant<t_HEAD, t_TAIL...>& lhs,
               const variant<t_HEAD, t_TAIL...>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessThan(lhs, rhs);
}
 
template <class t_HEAD, class... t_TAIL>
bool operator>(const variant<t_HEAD, t_TAIL...>& lhs,
               const variant<t_HEAD, t_TAIL...>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
    return ImpUtil::GreaterThan(lhs, rhs);
}
 
template <class t_HEAD, class... t_TAIL>
bool operator<=(const variant<t_HEAD, t_TAIL...>& lhs,
                const variant<t_HEAD, t_TAIL...>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (lhs.valueless_by_exception()) {
        return true;
    }
    else if (rhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() < rhs.index();
    }
    return ImpUtil::LessOrEqual(lhs, rhs);
}
 
template <class t_HEAD, class... t_TAIL>
bool operator>=(const variant<t_HEAD, t_TAIL...>& lhs,
                const variant<t_HEAD, t_TAIL...>& rhs)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
 
    if (rhs.valueless_by_exception()) {
        return true;
    }
    else if (lhs.valueless_by_exception()) {
        return false;
    }
    else if (lhs.index() != rhs.index()) {
        return lhs.index() > rhs.index();
    }
 
    return ImpUtil::GreaterOrEqual(lhs, rhs);
}
 
#if defined BSLS_COMPILERFEATURES_SUPPORT_THREE_WAY_COMPARISON &&             \
    defined BSLS_LIBRARYFEATURES_HAS_CPP20_CONCEPTS
 
template <class... t_ALTS>
    requires(std::three_way_comparable<t_ALTS> && ...)
constexpr std::common_comparison_category_t<
    std::compare_three_way_result_t<t_ALTS>...>
operator<=>(const variant<t_ALTS...>& lhs, const variant<t_ALTS...>& rhs)
{
    using RET = std::common_comparison_category_t<
        std::compare_three_way_result_t<t_ALTS>...>;
 
    const size_t lhs_index = lhs.index();
    const size_t rhs_index = rhs.index();
    if ((lhs_index != variant_npos) && (rhs_index != variant_npos)) {
        if (lhs_index == rhs_index) {
            return BloombergLP::bslstl::Variant_ImpUtil::visitId<RET>(
                    [&lhs]<size_t t_INDEX>(bsl::in_place_index_t<t_INDEX>,
                                           auto&& rhs_value) {
                        return bsl::get<t_INDEX>(lhs) <=> rhs_value;
                    },
                    rhs);
        }
        else {
            return lhs_index <=> rhs_index;
        }
    }
    else {
        if (lhs_index == variant_npos) {
            if (rhs_index == variant_npos)
                return std::strong_ordering::equal;
            else
                return std::strong_ordering::less;
        }
        else
            return std::strong_ordering::greater;
    }
}
#endif
 
// }}} END GENERATED CODE
#endif
}  // close namespace bsl
 
#else // if ! defined(DEFINED_BSLSTL_VARIANT_H)
# error Not valid except when included from bslstl_variant.h
#endif // ! defined(COMPILING_BSLSTL_VARIANT_H)
 
#endif // ! defined(INCLUDED_BSLSTL_VARIANT_CPP03)
 
// ----------------------------------------------------------------------------
// Copyright 2023 Bloomberg Finance L.P.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// ----------------------------- END-OF-FILE ----------------------------------
 
/** @} */
/** @} */
/** @} */